// Type definitions for Dojo v1.9
// Project: http://dojotoolkit.org
// Definitions by: Michael Van Sickle <https://github.com/vansimke>
// Definitions: https://github.com/borisyankov/DefinitelyTyped

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

declare module dijit {
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_BidiSupport.html
     *
     * Deprecated module for enabling textdir support in the dijit widgets.   New code should just define
     * has("dojo-bidi") to return true, rather than manually requiring this module.
     * 
     */
    interface _BidiSupport{(): void}
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/BackgroundIframe.html
     *
     * For IE/FF z-index shenanigans. id attribute is required.
     * new dijit.BackgroundIframe(node).
     * 
     * Makes a background iframe as a child of node, that fills
     * area (and position) of node
     * 
     * @param node     
     */
    interface BackgroundIframe{(node: HTMLElement): void}
    module BackgroundIframe {
        /**
         * destroy the iframe
         * 
         */
        interface destroy{(): void}
        /**
         * Resize the iframe so it's the same size as node.
         * Needed on IE6 and IE/quirks because height:100% doesn't work right.
         * 
         * @param node             
         */
        interface resize{(node: any): void}
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/hccss.html
     *
     * Test if computer is in high contrast mode, and sets dijit_a11y flag on <body> if it is.
     * Deprecated, use dojo/hccss instead.
     * 
     */
    interface hccss{(): void}
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_AttachMixin.html
     *
     * Mixin for widgets to attach to dom nodes and setup events via
     * convenient data-dojo-attach-point and data-dojo-attach-event DOM attributes.
     * 
     * Superclass of _TemplatedMixin, and can also be used standalone when templates are pre-rendered on the
     * server.
     * 
     * Does not [yet] handle widgets like ContentPane with this.containerNode set.   It should skip
     * scanning for data-dojo-attach-point and data-dojo-attach-event inside this.containerNode, but it
     * doesn't.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
     */
    class _AttachMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        /**
         * Search descendants of this.containerNode for data-dojo-attach-point and data-dojo-attach-event.
         * Should generally be left false (the default value) both for performance and to avoid failures when
         * this.containerNode holds other _AttachMixin instances with their own attach points and events.
         * 
         */
        "searchContainerNode": boolean;
        /**
         * Attach to DOM nodes marked with special attributes.
         * 
         */
        buildRendering(): void;
        /**
         * 
         */
        destroyRendering(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_Container.html
     *
     * Mixin for widgets that contain HTML and/or a set of widget children.
     * 
     */
    class _Container {
        constructor();
        /**
         * Makes the given widget a child of this widget.
         * Inserts specified child widget's dom node as a child of this widget's
         * container node, and possibly does other processing (such as layout).
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex?: number): void;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;

    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_Contained.html
     *
     * Mixin for widgets that are children of a container widget
     * 
     */
    class _Contained {
        constructor();
        /**
         * Returns the index of this widget within its container parent.
         * It returns -1 if the parent does not exist, or if the parent
         * is not a dijit/_Container
         * 
         */
        getIndexInParent(): any;
        /**
         * Returns null if this is the last child of the parent,
         * otherwise returns the next element sibling to the "right".
         * 
         */
        getNextSibling(): any;
        /**
         * Returns null if this is the first child of the parent,
         * otherwise returns the next element sibling to the "left".
         * 
         */
        getPreviousSibling(): any;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_DialogMixin.html
     *
     * This provides functions useful to Dialog and TooltipDialog
     * 
     */
    class _DialogMixin {
        constructor();
        /**
         * Callback when the user hits the submit button.
         * Override this method to handle Dialog execution.
         * After the user has pressed the submit button, the Dialog
         * first calls onExecute() to notify the container to hide the
         * dialog and restore focus to wherever it used to be.
         * 
         * Then this method is called.
         * 
         * @param formContents             
         */
        execute(formContents: Object): void;
        /**
         * Called when user has pressed the Dialog's cancel button, to notify container.
         * Developer shouldn't override or connect to this method;
         * it's a private communication device between the TooltipDialog
         * and the thing that opened it (ex: dijit/form/DropDownButton)
         * 
         */
        onCancel(): void;
        /**
         * Called when user has pressed the dialog's OK button, to notify container.
         * Developer shouldn't override or connect to this method;
         * it's a private communication device between the TooltipDialog
         * and the thing that opened it (ex: dijit/form/DropDownButton)
         * 
         */
        onExecute(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_CssStateMixin.html
     *
     * Mixin for widgets to set CSS classes on the widget DOM nodes depending on hover/mouse press/focus
     * state changes, and also higher-level state changes such becoming disabled or selected.
     * By mixing this class into your widget, and setting the this.baseClass attribute, it will automatically
     * maintain CSS classes on the widget root node (this.domNode) depending on hover,
     * active, focus, etc. state.   Ex: with a baseClass of dijitButton, it will apply the classes
     * dijitButtonHovered and dijitButtonActive, as the user moves the mouse over the widget and clicks it.
     * 
     * It also sets CSS like dijitButtonDisabled based on widget semantic state.
     * 
     * By setting the cssStateNodes attribute, a widget can also track events on subnodes (like buttons
     * within the widget).
     * 
     */
    class _CssStateMixin {
        constructor();
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_FocusMixin.html
     *
     * Mixin to widget to provide _onFocus() and _onBlur() methods that
     * fire when a widget or its descendants get/lose focus
     * 
     */
    class _FocusMixin {
        constructor();
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_HasDropDown.html
     *
     * Mixin for widgets that need drop down ability.
     * 
     */
    class _HasDropDown extends dijit._FocusMixin {
        constructor();
        /**
         * Set to true to make the drop down at least as wide as this
         * widget.  Set to false if the drop down should just be its
         * default width.
         * 
         */
        "autoWidth": boolean;
        /**
         * The widget to display as a popup.  This widget must be
         * defined before the startup function is called.
         * 
         */
        "dropDown": Object;
        /**
         * This variable controls the position of the drop down.
         * It's an array of strings with the following values:
         * 
         * before: places drop down to the left of the target node/widget, or to the right in
         * the case of RTL scripts like Hebrew and Arabic
         * after: places drop down to the right of the target node/widget, or to the left in
         * the case of RTL scripts like Hebrew and Arabic
         * above: drop down goes above target node
         * below: drop down goes below target node
         * The list is positions is tried, in order, until a position is found where the drop down fits
         * within the viewport.
         * 
         */
        "dropDownPosition": Object;
        /**
         * Set to true to make the drop down exactly as wide as this
         * widget.  Overrides autoWidth.
         * 
         */
        "forceWidth": boolean;
        /**
         * The max height for our dropdown.
         * Any dropdown taller than this will have scrollbars.
         * Set to 0 for no max height, or -1 to limit height to available space in viewport
         * 
         */
        "maxHeight": number;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Closes the drop down on this widget
         * 
         * @param focus If true, refocuses the button widget             
         */
        closeDropDown(focus: boolean): void;
        /**
         * 
         */
        destroy(): void;
        /**
         * Returns true if the dropdown exists and it's data is loaded.  This can
         * be overridden in order to force a call to loadDropDown().
         * 
         */
        isLoaded(): boolean;
        /**
         * Creates the drop down if it doesn't exist, loads the data
         * if there's an href and it hasn't been loaded yet, and
         * then opens the drop down.  This is basically a callback when the
         * user presses the down arrow button to open the drop down.
         * 
         */
        loadAndOpenDropDown(): any;
        /**
         * Creates the drop down if it doesn't exist, loads the data
         * if there's an href and it hasn't been loaded yet, and then calls
         * the given callback.
         * 
         * @param loadCallback             
         */
        loadDropDown(loadCallback: Function): void;
        /**
         * Opens the dropdown for this widget.   To be called only when this.dropDown
         * has been created and is ready to display (ie, it's data is loaded).
         * 
         */
        openDropDown(): any;
        /**
         * set up nodes and connect our mouse and keyboard events
         * 
         */
        postCreate(): void;
        /**
         * Callback when the user presses the down arrow button or presses
         * the down arrow key to open/close the drop down.
         * Toggle the drop-down widget; if it is up, close it, if not, open it
         * 
         */
        toggleDropDown(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_KeyNavMixin.html
     *
     * A mixin to allow arrow key and letter key navigation of child or descendant widgets.
     * It can be used by dijit/_Container based widgets with a flat list of children,
     * or more complex widgets like dijit/Tree.
     * 
     * To use this mixin, the subclass must:
     * 
     * - Implement  _getNext(), _getFirst(), _getLast(), _onLeftArrow(), _onRightArrow()
     *   _onDownArrow(), _onUpArrow() methods to handle home/end/left/right/up/down keystrokes.
     *   Next and previous in this context refer to a linear ordering of the descendants used
     *   by letter key search.
     * - Set all descendants' initial tabIndex to "-1"; both initial descendants and any
     *   descendants added later, by for example addChild()
     * - Define childSelector to a function or string that identifies focusable descendant widgets
     * Also, child widgets must implement a focus() method.
     * 
     */
    class _KeyNavMixin extends dijit._FocusMixin {
        constructor();
        /**
         * Selector (passed to on.selector()) used to identify what to treat as a child widget.   Used to monitor
         * focus events and set this.focusedChild.   Must be set by implementing class.   If this is a string
         * (ex: "> *") then the implementing class must require dojo/query.
         * 
         */
        "childSelector": any;
        /**
         * The currently focused child widget, or null if there isn't one
         * 
         */
        "focusedChild": Object;
        /**
         * If multiple characters are typed where each keystroke happens within
         * multiCharSearchDuration of the previous keystroke,
         * search for nodes matching all the keystrokes.
         * 
         * For example, typing "ab" will search for entries starting with
         * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
         * 
         */
        "multiCharSearchDuration": number;
        /**
         * Tab index of the container; same as HTML tabIndex attribute.
         * Note then when user tabs into the container, focus is immediately
         * moved to the first item in the container.
         * 
         */
        "tabIndex": string;
        /**
         * Default focus() implementation: focus the first child.
         * 
         */
        focus(): void;
        /**
         * Focus specified child widget.
         * 
         * @param widget Reference to container's child widget             
         * @param last If true and if widget has multiple focusable nodes, focus thelast one instead of the first one             
         */
        focusChild(widget: dijit._WidgetBase, last: boolean): void;
        /**
         * Focus the first focusable child in the container.
         * 
         */
        focusFirstChild(): void;
        /**
         * Focus the last focusable child in the container.
         * 
         */
        focusLastChild(): void;
        /**
         * 
         */
        postCreate(): void;
        /**
         * When a key is pressed that matches a child item,
         * this method is called so that a widget can take appropriate action is necessary.
         * 
         * @param item             
         * @param evt             
         * @param searchString             
         * @param numMatches             
         */
        onKeyboardSearch(item: dijit._WidgetBase, evt: Event, searchString: String, numMatches: number): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_KeyNavContainer.html
     *
     * A _Container with keyboard navigation of its children.
     * Provides normalized keyboard and focusing code for Container widgets.
     * To use this mixin, call connectKeyNavHandlers() in postCreate().
     * Also, child widgets must implement a focus() method.
     * 
     */
    class _KeyNavContainer extends dijit._FocusMixin implements dijit._KeyNavMixin, dijit._Container {
        constructor();
        /**
         * The currently focused child widget, or null if there isn't one
         * 
         */
        "focusedChild": Object;
        /**
         * If multiple characters are typed where each keystroke happens within
         * multiCharSearchDuration of the previous keystroke,
         * search for nodes matching all the keystrokes.
         * 
         * For example, typing "ab" will search for entries starting with
         * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
         * 
         */
        "multiCharSearchDuration": number;
        /**
         * Tab index of the container; same as HTML tabIndex attribute.
         * Note then when user tabs into the container, focus is immediately
         * moved to the first item in the container.
         * 
         */
        "tabIndex": string;
        /**
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * 
         * @param node             
         */
        childSelector(node: HTMLElement): any;
        /**
         * Deprecated.  You can call this in postCreate() to attach the keyboard handlers to the container,
         * but the preferred method is to override _onLeftArrow() and _onRightArrow(), or
         * _onUpArrow() and _onDownArrow(), to call focusPrev() and focusNext().
         * 
         * @param prevKeyCodes Key codes for navigating to the previous child.             
         * @param nextKeyCodes Key codes for navigating to the next child.             
         */
        connectKeyNavHandlers(prevKeyCodes: dojo.keys, nextKeyCodes: dojo.keys): void;
        /**
         * Default focus() implementation: focus the first child.
         * 
         */
        focus(): void;
        /**
         * Focus specified child widget.
         * 
         * @param widget Reference to container's child widget             
         * @param last If true and if widget has multiple focusable nodes, focus thelast one instead of the first one             
         */
        focusChild(widget: dijit._WidgetBase, last: boolean): void;
        /**
         * Focus the first focusable child in the container.
         * 
         */
        focusFirstChild(): void;
        /**
         * Focus the last focusable child in the container.
         * 
         */
        focusLastChild(): void;
        /**
         * Focus the next widget
         * 
         */
        focusNext(): void;
        /**
         * Focus the last focusable node in the previous widget
         * (ex: go to the ComboButton icon section rather than button section)
         * 
         */
        focusPrev(): void;
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * 
         */
        startup(): void;
        /**
         * 
         */
        startupKeyNavChildren(): void;
        /**
         * When a key is pressed that matches a child item,
         * this method is called so that a widget can take appropriate action is necessary.
         * 
         * @param item             
         * @param evt             
         * @param searchString             
         * @param numMatches             
         */
        onKeyboardSearch(item: dijit._WidgetBase, evt: Event, searchString: String, numMatches: number): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_OnDijitClickMixin.html
     *
     * Deprecated.   New code should access the dijit/a11yclick event directly, ex:
     * 
     * this.own(on(node, a11yclick, function(){ ... }));
     * Mixing in this class will make _WidgetBase.connect(node, "ondijitclick", ...) work.
     * It also used to be necessary to make templates with ondijitclick work, but now you can just require
     * dijit/a11yclick.
     * 
     */
    class _OnDijitClickMixin {
        constructor();
        /**
         * Custom press, release, and click synthetic events
         * which trigger on a left mouse click, touch, or space/enter keyup.
         * 
         */
        "a11yclick": Object;
        /**
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: any, method: any): any;
    }
    module _OnDijitClickMixin {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_OnDijitClickMixin.a11yclick.html
         *
         * Custom press, release, and click synthetic events
         * which trigger on a left mouse click, touch, or space/enter keyup.
         * 
         */
        interface a11yclick {
            /**
             * Logical click operation for mouse, touch, or keyboard (space/enter key)
             * 
             * @param node             
             * @param listener             
             */
            click(node: any, listener: any): void;
            /**
             * Mouse cursor or a finger is dragged over the given node.
             * 
             * @param node             
             * @param listener             
             */
            move(node: any, listener: any): void;
            /**
             * Mousedown (left button), touchstart, or keydown (space or enter) corresponding to logical click operation.
             * 
             * @param node             
             * @param listener             
             */
            press(node: any, listener: any): void;
            /**
             * Mouseup (left button), touchend, or keyup (space or enter) corresponding to logical click operation.
             * 
             * @param node             
             * @param listener             
             */
            release(node: any, listener: any): void;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_PaletteMixin.html
     *
     * A keyboard accessible palette, for picking a color/emoticon/etc.
     * A mixin for a grid showing various entities, so the user can pick a certain entity.
     * 
     */
    class _PaletteMixin extends dijit._CssStateMixin {
        constructor();
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        /**
         * CSS class applied to each cell in the palette
         * 
         */
        "cellClass": string;
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        /**
         * Number of milliseconds before a held key or button becomes typematic
         * 
         */
        "defaultTimeout": number;
        /**
         * Constructor for Object created for each cell of the palette.
         * dyeClass should implement the dijit/_PaletteMixin.__Dye interface.
         * 
         */
        "dyeClass": Object;
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        /**
         * Widget tab index.
         * 
         */
        "tabIndex": string;
        /**
         * Fraction of time used to change the typematic timer between events
         * 1.0 means that each typematic event fires at defaultTimeout intervals
         * Less than 1.0 means that each typematic event fires at an increasing faster rate
         * 
         */
        "timeoutChangeRate": number;
        /**
         * Currently selected color/emoticon/etc.
         * 
         */
        "value": string;
        /**
         * Focus this widget.  Puts focus on the most recently focused cell.
         * 
         */
        focus(): void;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Callback when a cell is selected.
         * 
         * @param value Value corresponding to cell.             
         */
        onChange(value: String): void;
    }
    module _PaletteMixin {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_PaletteMixin.__Dye.html
         *
         * Interface for the JS Object associated with a palette cell (i.e. DOMNode)
         * 
         * @param alias     
         * @param row     
         * @param col     
         */
        class __Dye {
            constructor(alias: String, row: any, col: any);
            /**
             * Add cell DOMNode inner structure
             * 
             * @param cell The surrounding cell             
             * @param blankGif URL for blank cell image             
             */
            fillCell(cell: HTMLElement, blankGif: String): void;
            /**
             * Return "value" of cell; meaning of "value" varies by subclass.
             * For example color hex value, emoticon ascii value etc, entity hex value.
             * 
             */
            getValue(): void;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_TemplatedMixin.html
     *
     * Mixin for widgets that are instantiated from a template
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
     */
    class _TemplatedMixin extends dijit._AttachMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        /**
         * 
         */
        "searchContainerNode": boolean;
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        /**
         * A string that represents the widget template.
         * Use in conjunction with dojo.cache() to load from a file.
         * 
         */
        "templateString": string;
        /**
         * Construct the UI for this widget from a template, setting this.domNode.
         * 
         */
        buildRendering(): void;
        /**
         * 
         */
        destroyRendering(): void;
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         * 
         * @param templateString The template             
         * @param alwaysUseString Don't cache the DOM tree for this template, even if it doesn't have any variables             
         * @param doc               OptionalThe target document.   Defaults to document global if unspecified.             
         */
        getCachedTemplate(templateString: String, alwaysUseString: boolean, doc: HTMLDocument): any;
    }
    module _TemplatedMixin {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_TemplatedMixin._templateCache.html
         *
         * 
         */
        interface _templateCache {
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_Templated.html
     *
     * Deprecated mixin for widgets that are instantiated from a template.
     * Widgets should use _TemplatedMixin plus if necessary _WidgetsInTemplateMixin instead.
     * 
     */
    class _Templated extends dijit._TemplatedMixin implements dijit._WidgetsInTemplateMixin {
        constructor();
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        /**
         * Used to provide a context require to the dojo/parser in order to be
         * able to use relative MIDs (e.g. ./Widget) in the widget's template.
         * 
         */
        "contextRequire": Function;
        /**
         * 
         */
        "searchContainerNode": boolean;
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        /**
         * A string that represents the widget template.
         * Use in conjunction with dojo.cache() to load from a file.
         * 
         */
        "templateString": string;
        /**
         * Should we parse the template to find widgets that might be
         * declared in markup inside it?  False by default.
         * 
         */
        "widgetsInTemplate": boolean;
        /**
         * Construct the UI for this widget from a template, setting this.domNode.
         * 
         */
        buildRendering(): void;
        /**
         * 
         */
        destroyRendering(): void;
        /**
         * 
         */
        startup(): void;
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_MenuBase.html
     *
     * Abstract base class for Menu and MenuBar.
     * Subclass should implement _onUpArrow(), _onDownArrow(), _onLeftArrow(), and _onRightArrow().
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class _MenuBase extends dijit._Widget implements dijit._TemplatedMixin, dijit._KeyNavContainer, dijit._CssStateMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * This Menu has been clicked (mouse or via space/arrow key) or opened as a submenu,
         * so mere mouseover will open submenus.  Focusing a menu via TAB does NOT automatically make it active
         * since TAB is a navigation operation and not a selection one.
         * For Windows apps, pressing the ALT key focuses the menubar menus (similar to TAB navigation) but the
         * menu is not active (ie no dropdown) until an item is clicked.
         * 
         */
        "activated": boolean;
        set(property:"activated", value: boolean): void;
        get(property:"activated"): boolean;
        watch(property:"activated", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A toggle to control whether or not a Menu gets focused when opened as a drop down from a MenuBar
         * or DropDownButton/ComboButton.   Note though that it always get focused when opened via the keyboard.
         * 
         */
        "autoFocus": boolean;
        set(property:"autoFocus", value: boolean): void;
        get(property:"autoFocus"): boolean;
        watch(property:"autoFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The currently focused child widget, or null if there isn't one
         * 
         */
        "focusedChild": Object;
        set(property:"focusedChild", value: Object): void;
        get(property:"focusedChild"): Object;
        watch(property:"focusedChild", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If multiple characters are typed where each keystroke happens within
         * multiCharSearchDuration of the previous keystroke,
         * search for nodes matching all the keystrokes.
         * 
         * For example, typing "ab" will search for entries starting with
         * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
         * 
         */
        "multiCharSearchDuration": number;
        set(property:"multiCharSearchDuration", value: number): void;
        get(property:"multiCharSearchDuration"): number;
        watch(property:"multiCharSearchDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to menu that displayed me
         * 
         */
        "parentMenu": Object;
        set(property:"parentMenu", value: Object): void;
        get(property:"parentMenu"): Object;
        watch(property:"parentMenu", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * For a passive (unclicked) Menu, number of milliseconds before hovering (without clicking) will cause
         * the popup to open.  Default is Infinity, meaning you need to click the menu to open it.
         * 
         */
        "passivePopupDelay": number;
        set(property:"passivePopupDelay", value: number): void;
        get(property:"passivePopupDelay"): number;
        watch(property:"passivePopupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * After a menu has been activated (by clicking on it etc.), number of milliseconds before hovering
         * (without clicking) another MenuItem causes that MenuItem's popup to automatically open.
         * 
         */
        "popupDelay": number;
        set(property:"popupDelay", value: number): void;
        get(property:"popupDelay"): number;
        watch(property:"popupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Currently selected (a.k.a. highlighted) MenuItem, or null if no MenuItem is selected.
         * If a submenu is open, will be set to MenuItem that displayed the submenu.   OTOH, if
         * this Menu is in passive mode (i.e. hasn't been clicked yet), will be null, because
         * "selected" is not merely "hovered".
         * 
         */
        "selected": Object;
        set(property:"selected", value: Object): void;
        get(property:"selected"): Object;
        watch(property:"selected", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Tab index of the container; same as HTML tabIndex attribute.
         * Note then when user tabs into the container, focus is immediately
         * moved to the first item in the container.
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A string that represents the widget template.
         * Use in conjunction with dojo.cache() to load from a file.
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Selector (passed to on.selector()) used to identify MenuItem child widgets, but exclude inert children
         * like MenuSeparator.  If subclass overrides to a string (ex: "> *"), the subclass must require dojo/query.
         * 
         * @param node             
         */
        childSelector(node: HTMLElement): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Deprecated.  You can call this in postCreate() to attach the keyboard handlers to the container,
         * but the preferred method is to override _onLeftArrow() and _onRightArrow(), or
         * _onUpArrow() and _onDownArrow(), to call focusPrev() and focusNext().
         * 
         * @param prevKeyCodes Key codes for navigating to the previous child.             
         * @param nextKeyCodes Key codes for navigating to the next child.             
         */
        connectKeyNavHandlers(prevKeyCodes: dojo.keys, nextKeyCodes: dojo.keys): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Default focus() implementation: focus the first child.
         * 
         */
        focus(): void;
        /**
         * Focus specified child widget.
         * 
         * @param widget Reference to container's child widget             
         * @param last If true and if widget has multiple focusable nodes, focus thelast one instead of the first one             
         */
        focusChild(widget: dijit._WidgetBase, last: boolean): void;
        /**
         * Focus the first focusable child in the container.
         * 
         */
        focusFirstChild(): void;
        /**
         * Focus the last focusable child in the container.
         * 
         */
        focusLastChild(): void;
        /**
         * Focus the next widget
         * 
         */
        focusNext(): void;
        /**
         * Focus the last focusable node in the previous widget
         * (ex: go to the ComboButton icon section rather than button section)
         * 
         */
        focusPrev(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * 
         */
        startupKeyNavChildren(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Attach point for notification about when the user cancels the current menu
         * This is an internal mechanism used for Menus to signal to their parent to
         * close them.  In general developers should not attach to or override this method.
         * 
         * @param closeAll             
         */
        onCancel(closeAll: boolean): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Attach point for notification about when a menu item has been executed.
         * This is an internal mechanism used for Menus to signal to their parent to
         * close them, because they are about to execute the onClick handler.  In
         * general developers should not attach to or override this method.
         * 
         */
        onExecute(): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Called when cursor is over a MenuItem.
         * 
         * @param item             
         */
        onItemHover(item: dijit.MenuItem): void;
        /**
         * Callback fires when mouse exits a MenuItem
         * 
         * @param item             
         */
        onItemUnhover(item: dijit.MenuItem): void;
        /**
         * Attach point for notification about when a menu item has been searched for
         * via the keyboard search mechanism.
         * 
         * @param item             
         * @param evt             
         * @param searchString             
         * @param numMatches             
         */
        onKeyboardSearch(item: dijit.MenuItem, evt: Event, searchString: String, numMatches: number): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_WidgetsInTemplateMixin.html
     *
     * Mixin to supplement _TemplatedMixin when template contains widgets
     * 
     */
    class _WidgetsInTemplateMixin {
        constructor();
        /**
         * Used to provide a context require to the dojo/parser in order to be
         * able to use relative MIDs (e.g. ./Widget) in the widget's template.
         * 
         */
        "contextRequire": Function;
        /**
         * Should we parse the template to find widgets that might be
         * declared in markup inside it?  (Remove for 2.0 and assume true)
         * 
         */
        "widgetsInTemplate": boolean;
        /**
         * 
         */
        startup(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_WidgetBase.html
     *
     * Future base class for all Dijit widgets.
     * Future base class for all Dijit widgets.
     * _Widget extends this class adding support for various features needed by desktop.
     * 
     * Provides stubs for widget lifecycle methods for subclasses to extend, like postMixInProperties(), buildRendering(),
     * postCreate(), startup(), and destroy(), and also public API methods like set(), get(), and watch().
     * 
     * Widgets can provide custom setters/getters for widget attributes, which are called automatically by set(name, value).
     * For an attribute XXX, define methods _setXXXAttr() and/or _getXXXAttr().
     * 
     * _setXXXAttr can also be a string/hash/array mapping from a widget attribute XXX to the widget's DOMNodes:
     * 
     * DOM node attribute
     *   _setFocusAttr: {node: "focusNode", type: "attribute"}
     *   _setFocusAttr: "focusNode"  (shorthand)
     *   _setFocusAttr: ""       (shorthand, maps to this.domNode)
     * Maps this.focus to this.focusNode.focus, or (last example) this.domNode.focus
     * 
     * DOM node innerHTML
     *   _setTitleAttr: { node: "titleNode", type: "innerHTML" }
     * Maps this.title to this.titleNode.innerHTML
     * 
     * DOM node innerText
     *   _setTitleAttr: { node: "titleNode", type: "innerText" }
     * Maps this.title to this.titleNode.innerText
     * 
     * DOM node CSS class
     *   _setMyClassAttr: { node: "domNode", type: "class" }
     * Maps this.myClass to this.domNode.className
     * 
     * If the value of _setXXXAttr is an array, then each element in the array matches one of the
     * formats of the above list.
     * 
     * If the custom setter is null, no action is performed other than saving the new value
     * in the widget (in this).
     * 
     * If no custom setter is defined for an attribute, then it will be copied
     * to this.focusNode (if the widget defines a focusNode), or this.domNode otherwise.
     * That's only done though for attributes that match DOMNode attributes (title,
     * alt, aria-labelledby, etc.)
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class _WidgetBase extends dojo.Stateful implements dijit.Destroyable {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": Object;
        set(property:"style", value: Object): void;
        get(property:"style"): Object;
        watch(property:"style", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj?: Object, callbackArgs?: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         */
        isValid: any;
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: String, func: Function): {remove:{():void}};
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: Function, func: Function): {remove:{():void}};
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(handle:any): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position?: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position?: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position?: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position?: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position?: number): any;
        /**
         * Processing after the DOM fragment is created
         * Called after the DOM fragment has been created, but not necessarily
         * added to the document.  Do not include any operations which rely on
         * node dimensions or placement.
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_Widget.html
     *
     * Old base class for widgets.   New widgets should extend dijit/_WidgetBase instead
     * Old Base class for Dijit widgets.
     * 
     * Extends _WidgetBase, adding support for:
     * 
     * declaratively/programatically specifying widget initialization parameters like
     *   onMouseMove="foo" that call foo when this.domNode gets a mousemove event
     * ondijitclick:
     *   Support new data-dojo-attach-event="ondijitclick: ..." that is triggered by a mouse click or a SPACE/ENTER keypress
     * focus related functions:
     *   In particular, the onFocus()/onBlur() callbacks.   Driven internally by
     *   dijit/_base/focus.js.
     * deprecated methods
     * onShow(), onHide(), onClose()
     * Also, by loading code in dijit/_base, turns on:
     * 
     * browser sniffing (putting browser class like dj_ie on <html> node)
     * high contrast mode sniffing (add dijit_a11y class to <body> if machine is in high contrast mode)
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class _Widget extends dijit._WidgetBase implements dijit._OnDijitClickMixin, dijit._FocusMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Custom press, release, and click synthetic events
         * which trigger on a left mouse click, touch, or space/enter keyup.
         * 
         */
        "a11yclick": Object;
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Defines a type of widget.
         * 
         */
        "dndType": string;
        set(property:"dndType", value: string): void;
        get(property:"dndType"): string;
        watch(property:"dndType", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "observer": string;
        set(property:"observer", value: string): void;
        get(property:"observer"): string;
        watch(property:"observer", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A parameter needed by RadioGroupSlide only. An optional paramter to force
         * the ContentPane to slide in from a set direction. Defaults
         * to "random", or specify one of "top", "left", "right", "bottom"
         * to slideFrom top, left, right, or bottom.
         * 
         */
        "slideFrom": string;
        set(property:"slideFrom", value: string): void;
        get(property:"slideFrom"): string;
        watch(property:"slideFrom", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": Object;
        set(property:"style", value: Object): void;
        get(property:"style"): Object;
        watch(property:"style", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_TimePicker.html
     *
     * A time picker dropdown, used by dijit/form/TimeTextBox.
     * This widget is not available as a standalone widget due to lack of accessibility support.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree     
     */
    class _TimePicker extends dijit._WidgetBase implements dijit.form._ListMouseMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * The root className to use for the various states of this widget
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * ISO-8601 string representing the amount by which
         * every clickable element in the time picker increases.
         * Set in local time, without a time zone.
         * Example: T00:15:00 creates 15 minute increments
         * Must divide dijit/_TimePicker.visibleIncrement evenly
         * 
         */
        "clickableIncrement": string;
        set(property:"clickableIncrement", value: string): void;
        get(property:"clickableIncrement"): string;
        watch(property:"clickableIncrement", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Specifies valid range of times (start time, end time)
         * 
         */
        "constraints": Object;
        set(property:"constraints", value: Object): void;
        get(property:"constraints"): Object;
        watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * The string to filter by
         * 
         */
        "filterString": string;
        set(property:"filterString", value: string): void;
        get(property:"filterString"): string;
        watch(property:"filterString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * currently selected node
         * 
         */
        "selected": HTMLElement;
        set(property:"selected", value: HTMLElement): void;
        get(property:"selected"): HTMLElement;
        watch(property:"selected", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Date to display.
         * Defaults to current time and date.
         * Can be a Date object or an ISO-8601 string.
         * If you specify the GMT time zone (-01:00),
         * the time will be converted to the local time in the local time zone.
         * Otherwise, the time is considered to be in the local time zone.
         * If you specify the date and isDate is true, the date is used.
         * Example: if your local time zone is GMT -05:00,
         * T10:00:00 becomes T10:00:00-05:00 (considered to be local time),
         * T10:00:00-01:00 becomes T06:00:00-05:00 (4 hour difference),
         * T10:00:00Z becomes T05:00:00-05:00 (5 hour difference between Zulu and local time)
         * yyyy-mm-ddThh:mm:ss is the format to set the date and time
         * Example: 2007-06-01T09:00:00
         * 
         */
        "value": string;
        set(property:"value", value: string): void;
        get(property:"value"): string;
        watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * ISO-8601 string representing the amount by which
         * every element with a visible time in the time picker increases.
         * Set in local time, without a time zone.
         * Example: T01:00:00 creates text in every 1 hour increment
         * 
         */
        "visibleIncrement": string;
        set(property:"visibleIncrement", value: string): void;
        get(property:"visibleIncrement"): string;
        watch(property:"visibleIncrement", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Called from dijit/form/_DateTimeTextBox to pass a keypress event
         * from the dijit/form/TimeTextBox to be handled in this widget
         * 
         * @param e             
         */
        handleKey(e: Event): any;
        /**
         * May be overridden to disable certain dates in the TimePicker e.g. isDisabledDate=locale.isWeekend
         * 
         * @param dateObject             
         * @param locale               Optional            
         */
        isDisabledDate(dateObject: Date, locale: String): boolean;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * Processing after the DOM fragment is created
         * Called after the DOM fragment has been created, but not necessarily
         * added to the document.  Do not include any operations which rely on
         * node dimensions or placement.
         * 
         */
        postCreate(): void;
        /**
         * 
         */
        postMixInProperties(): void;
        /**
         * Select the first displayed item in the list.
         * 
         */
        selectFirstNode(): void;
        /**
         * Select the last displayed item in the list
         * 
         */
        selectLastNode(): void;
        /**
         * Select the item just below the current selection.
         * If nothing selected, select first node.
         * 
         */
        selectNextNode(): void;
        /**
         * Select the item just above the current selection.
         * If nothing selected, select last node (if
         * you select Previous and try to keep scrolling up the list).
         * 
         */
        selectPreviousNode(): void;
        /**
         * Format a Date object as a string according a subset of the ISO-8601 standard
         * When options.selector is omitted, output follows RFC3339
         * The local time zone is included as an offset from GMT, except when selector=='time' (time without a date)
         * Does not check bounds.  Only years between 100 and 9999 are supported.
         * 
         * @param dateObject A Date object             
         * @param options               OptionalAn object with the following properties:selector (String): "date" or "time" for partial formatting of the Date object.Both date and time will be formatted by default.zulu (Boolean): if true, UTC/GMT is used for a timezonemilliseconds (Boolean): if true, output milliseconds            
         */
        serialize(dateObject: Date, options: Object): any;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Used set('value') instead.
         * 
         * @param value             
         */
        setValue(value: Date): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Notification that a time was selected.  It may be the same as the previous value.
         * 
         * @param time             
         */
        onChange(time: Date): void;
        /**
         * 
         * @param node             
         */
        onClick(node: HTMLElement): void;
        /**
         * 
         * @param node             
         */
        onDeselect(node: HTMLElement): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * 
         * @param node             
         */
        onHover(node: HTMLElement): void;
        /**
         * 
         */
        onOpen(): void;
        /**
         * 
         * @param node             
         */
        onSelect(node: HTMLElement): void;
        /**
         * 
         * @param node             
         */
        onUnhover(node: HTMLElement): void;
    }
    module _TimePicker {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_TimePicker.__Constraints.html
         *
         * 
         */
        class __Constraints {
            constructor();
            /**
             * override strings for am in times
             * 
             */
            "am": string;
            /**
             * See dijit/_TimePicker.clickableIncrement
             * 
             */
            "clickableIncrement": string;
            /**
             * override pattern with this string
             * 
             */
            "datePattern": string;
            /**
             * choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'
             * 
             */
            "formatLength": string;
            /**
             * (format only) use 4 digit years whenever 2 digit years are called for
             * 
             */
            "fullYear": boolean;
            /**
             * override the locale used to determine formatting rules
             * 
             */
            "locale": string;
            /**
             * override strings for pm in times
             * 
             */
            "pm": string;
            /**
             * choice of 'time','date' (default: date and time)
             * 
             */
            "selector": string;
            /**
             * (parse only) strict parsing, off by default
             * 
             */
            "strict": boolean;
            /**
             * override pattern with this string
             * 
             */
            "timePattern": string;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Destroyable.html
     *
     * Mixin to track handles and release them when instance is destroyed.
     * Call this.own(...) on list of handles (returned from dojo/aspect, dojo/on,
     * dojo/Stateful::watch, or any class (including widgets) with a destroyRecursive() or destroy() method.
     * Then call destroy() later to destroy this instance and release the resources.
     * 
     */
    class Destroyable {
        constructor();
        /**
         * Destroy this class, releasing any resources registered via own().
         * 
         * @param preserveDom             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(handle:any): any;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/CalendarLite.html
     *
     * Lightweight version of Calendar widget aimed towards mobile use
     * A simple GUI for choosing a date in the context of a monthly calendar.
     * This widget can't be used in a form because it doesn't serialize the date to an
     * <input> field.  For a form element, use dijit/form/DateTextBox instead.
     * 
     * Note that the parser takes all dates attributes passed in the
     * RFC 3339 format, e.g. 2005-06-30T08:05:00-07:00
     * so that they are serializable and locale-independent.
     * 
     * Also note that this widget isn't keyboard accessible; use dijit.Calendar for that
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree     
     */
    class CalendarLite extends dijit._WidgetBase implements dijit._TemplatedMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Date object containing the currently focused date, or the date which would be focused
         * if the calendar itself was focused.   Also indicates which year and month to display,
         * i.e. the current "page" the calendar is on.
         * 
         */
        "currentFocus": Date;
        set(property:"currentFocus", value: Date): void;
        get(property:"currentFocus"): Date;
        watch(property:"currentFocus", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
        /**
         * JavaScript namespace to find calendar routines.  If unspecified, uses Gregorian calendar routines
         * at dojo/date and dojo/date/locale.
         * 
         */
        "datePackage": string;
        set(property:"datePackage", value: string): void;
        get(property:"datePackage"): string;
        watch(property:"datePackage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "dateTemplateString": string;
        set(property:"dateTemplateString", value: string): void;
        get(property:"dateTemplateString"): string;
        watch(property:"dateTemplateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * How to represent the days of the week in the calendar header. See locale
         * 
         */
        "dayWidth": string;
        set(property:"dayWidth", value: string): void;
        get(property:"dayWidth"): string;
        watch(property:"dayWidth", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * 
         */
        "dowTemplateString": string;
        set(property:"dowTemplateString", value: string): void;
        get(property:"dowTemplateString"): string;
        watch(property:"dowTemplateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Order fields are traversed when user hits the tab key
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The currently selected Date, initially set to invalid date to indicate no selection.
         * 
         */
        "value": Date;
        set(property:"value", value: Date): void;
        get(property:"value"): Date;
        watch(property:"value", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
        /**
         * 
         */
        "weekTemplateString": string;
        set(property:"weekTemplateString", value: string): void;
        get(property:"weekTemplateString"): string;
        watch(property:"weekTemplateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Focus the calendar by focusing one of the calendar cells
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * May be overridden to return CSS classes to associate with the date entry for the given dateObject,
         * for example to indicate a holiday in specified locale.
         * 
         * @param dateObject             
         * @param locale               Optional            
         */
        getClassForDate(dateObject: Date, locale: String): String;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Sets calendar's value to today's date
         * 
         */
        goToToday(): void;
        /**
         * May be overridden to disable certain dates in the calendar e.g. isDisabledDate=dojo.date.locale.isWeekend
         * 
         * @param dateObject             
         * @param locale               Optional            
         */
        isDisabledDate(dateObject: Date, locale: String): boolean;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called only when the selected date has changed
         * 
         * @param date             
         */
        onChange(date: Date): void;
    }
    module CalendarLite {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/CalendarLite._MonthWidget.html
         *
         * Displays name of current month padded to the width of the month
         * w/the longest name, so that changing months doesn't change width.
         * 
         * Create as:
         * 
         * new Calendar._MonthWidget({
         *         lang: ...,
         *         dateLocaleModule: ...
         *     })
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _MonthWidget extends dijit._WidgetBase {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
             * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
             * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
             * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
             * 
             * @param type Name of event (ex: "click") or extension event like touch.press.             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
             * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
             * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
             * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
             * 
             * @param type Name of event (ex: "click") or extension event like touch.press.             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * Processing after the DOM fragment is created
             * Called after the DOM fragment has been created, but not necessarily
             * added to the document.  Do not include any operations which rely on
             * node dimensions or placement.
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Declaration.html
     *
     * The Declaration widget allows a developer to declare new widget
     * classes directly from a snippet of markup.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class Declaration extends dijit._Widget {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * 
         */
        "defaults": Object;
        set(property:"defaults", value: Object): void;
        get(property:"defaults"): Object;
        watch(property:"defaults", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * List containing the prototype for this widget, and also any mixins,
         * ex: ["dijit._Widget", "dijit._Container"]
         * 
         */
        "mixins": Object;
        set(property:"mixins", value: Object): void;
        get(property:"mixins"): Object;
        watch(property:"mixins", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Name of class being declared, ex: "acme.myWidget"
         * 
         */
        "widgetClass": string;
        set(property:"widgetClass", value: string): void;
        get(property:"widgetClass"): string;
        watch(property:"widgetClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Calendar.html
     *
     * A simple GUI for choosing a date in the context of a monthly calendar.
     * See CalendarLite for general description.   Calendar extends CalendarLite, adding:
     * 
     * month drop down list
     * keyboard navigation
     * CSS classes for hover/mousepress on date, month, and year nodes
     * support of deprecated methods (will be removed in 2.0)
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree     
     */
    class Calendar extends dijit.CalendarLite implements dijit._Widget, dijit._CssStateMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        		/**
         * Custom press, release, and click synthetic events
         * which trigger on a left mouse click, touch, or space/enter keyup.
         * 
         */
        "a11yclick": Object;
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Date object containing the currently focused date, or the date which would be focused
         * if the calendar itself was focused.   Also indicates which year and month to display,
         * i.e. the current "page" the calendar is on.
         * 
         */
        "currentFocus": Date;
        set(property:"currentFocus", value: Date): void;
        get(property:"currentFocus"): Date;
        watch(property:"currentFocus", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
        /**
         * JavaScript namespace to find calendar routines.  If unspecified, uses Gregorian calendar routines
         * at dojo/date and dojo/date/locale.
         * 
         */
        "datePackage": string;
        set(property:"datePackage", value: string): void;
        get(property:"datePackage"): string;
        watch(property:"datePackage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "dateTemplateString": string;
        set(property:"dateTemplateString", value: string): void;
        get(property:"dateTemplateString"): string;
        watch(property:"dateTemplateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * How to represent the days of the week in the calendar header. See locale
         * 
         */
        "dayWidth": string;
        set(property:"dayWidth", value: string): void;
        get(property:"dayWidth"): string;
        watch(property:"dayWidth", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * 
         */
        "dowTemplateString": string;
        set(property:"dowTemplateString", value: string): void;
        get(property:"dowTemplateString"): string;
        watch(property:"dowTemplateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Defines a type of widget.
         * 
         */
        "dndType": string;
        set(property:"dndType", value: string): void;
        get(property:"dndType"): string;
        watch(property:"dndType", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "observer": string;
        set(property:"observer", value: string): void;
        get(property:"observer"): string;
        watch(property:"observer", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A parameter needed by RadioGroupSlide only. An optional paramter to force
         * the ContentPane to slide in from a set direction. Defaults
         * to "random", or specify one of "top", "left", "right", "bottom"
         * to slideFrom top, left, right, or bottom.
         * 
         */
        "slideFrom": string;
        set(property:"slideFrom", value: string): void;
        get(property:"slideFrom"): string;
        watch(property:"slideFrom", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Order fields are traversed when user hits the tab key
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The currently selected Date, initially set to invalid date to indicate no selection.
         * 
         */
        "value": Date;
        set(property:"value", value: Date): void;
        get(property:"value"): Date;
        watch(property:"value", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
        /**
         * 
         */
        "weekTemplateString": string;
        set(property:"weekTemplateString", value: string): void;
        get(property:"weekTemplateString"): string;
        watch(property:"weekTemplateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Focus the calendar by focusing one of the calendar cells
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * May be overridden to return CSS classes to associate with the date entry for the given dateObject,
         * for example to indicate a holiday in specified locale.
         * 
         * @param dateObject             
         * @param locale               Optional            
         */
        getClassForDate(dateObject: Date, locale: String): String;
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Sets calendar's value to today's date
         * 
         */
        goToToday(): void;
        /**
         * Provides keyboard navigation of calendar.
         * Called from _onKeyDown() to handle keydown on a stand alone Calendar,
         * and also from dijit/form/_DateTimeTextBox to pass a keydown event
         * from the dijit/form/DateTextBox to be handled in this widget
         * 
         * @param evt             
         */
        handleKey(evt: Event): any;
        /**
         * May be overridden to disable certain dates in the calendar e.g. isDisabledDate=dojo.date.locale.isWeekend
         * 
         * @param dateObject             
         * @param locale               Optional            
         */
        isDisabledDate(dateObject: Date, locale: String): boolean;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('value', ...) instead.
         * 
         * @param value             
         */
        setValue(value: Date): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * 
         * @param value             
         */
        onChange(value: any): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
        /**
         * Deprecated.   Notification that a date cell was selected.  It may be the same as the previous value.
         * Formerly used by dijit/form/_DateTimeTextBox (and thus dijit/form/DateTextBox)
         * to get notification when the user has clicked a date.  Now onExecute() (above) is used.
         * 
         * @param date             
         */
        onValueSelected(date: Date): void;
    }
    module Calendar {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/Calendar._MonthDropDown.html
         *
         * The list-of-months drop down from the MonthDropDownButton
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _MonthDropDown extends dijit._Widget implements dijit._TemplatedMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * List of names of months, possibly w/some undefined entries for Hebrew leap months
             * (ex: ["January", "February", undefined, "April", ...])
             * 
             */
            "months": Object;
            set(property:"months", value: Object): void;
            get(property:"months"): Object;
            watch(property:"months", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when month is selected from drop down
             * 
             * @param month             
             */
            onChange(month: number): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/Calendar._MonthDropDownButton.html
         *
         * DropDownButton for the current month.    Displays name of current month
         * and a list of month names in the drop down
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _MonthDropDownButton extends dijit.form.DropDownButton {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down at least as wide as this
             * widget.  Set to false if the drop down should just be its
             * default width.
             * 
             */
            "autoWidth": boolean;
            set(property:"autoWidth", value: boolean): void;
            get(property:"autoWidth"): boolean;
            watch(property:"autoWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            set(property:"dropDown", value: Object): void;
            get(property:"dropDown"): Object;
            watch(property:"dropDown", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            set(property:"dropDownPosition", value: Object): void;
            get(property:"dropDownPosition"): Object;
            watch(property:"dropDownPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            set(property:"forceWidth", value: boolean): void;
            get(property:"forceWidth"): boolean;
            watch(property:"forceWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Class to apply to DOMNode in button to make it display an icon
             * 
             */
            "iconClass": string;
            set(property:"iconClass", value: string): void;
            get(property:"iconClass"): string;
            watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Content to display in button.
             * 
             */
            "label": string;
            set(property:"label", value: string): void;
            get(property:"label"): string;
            watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The max height for our dropdown.
             * Any dropdown taller than this will have scrollbars.
             * Set to 0 for no max height, or -1 to limit height to available space in viewport
             * 
             */
            "maxHeight": number;
            set(property:"maxHeight", value: number): void;
            get(property:"maxHeight"): number;
            watch(property:"maxHeight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this to true to hide the label text and display only the icon.
             * (If showLabel=false then iconClass must be specified.)
             * Especially useful for toolbars.
             * If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
             * 
             * The exception case is for computers in high-contrast mode, where the label
             * will still be displayed, since the icon doesn't appear.
             * 
             */
            "showLabel": boolean;
            set(property:"showLabel", value: boolean): void;
            get(property:"showLabel"): boolean;
            watch(property:"showLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus: boolean): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            isLoaded(): boolean;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * 
             * @param callback             
             */
            loadDropDown(callback: Function): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Opens the dropdown for this widget.   To be called only when this.dropDown
             * has been created and is ready to display (ie, it's data is loaded).
             * 
             */
            openDropDown(): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('label', ...) instead.
             * 
             * @param content             
             */
            setLabel(content: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): boolean;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * 
             */
            onMonthSelect(): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/CheckedMenuItem.html
     *
     * A checkbox-like menu item for toggling on and off
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class CheckedMenuItem extends dijit.MenuItem {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Text for the accelerator (shortcut) key combination, a control, alt, etc. modified keystroke meant to
         * execute the menu item regardless of where the focus is on the page.
         * 
         * Note that although Menu can display accelerator keys, there is no infrastructure to actually catch and
         * execute those accelerators.
         * 
         */
        "accelKey": string;
        set(property:"accelKey", value: string): void;
        get(property:"accelKey"): string;
        watch(property:"accelKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Our checked state
         * 
         */
        "checked": boolean;
        set(property:"checked", value: boolean): void;
        get(property:"checked"): boolean;
        watch(property:"checked", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Character (or string) used in place of checkbox icon when display in high contrast mode
         * 
         */
        "checkedChar": string;
        set(property:"checkedChar", value: string): void;
        get(property:"checkedChar"): string;
        watch(property:"checkedChar", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If true, the menu item is disabled.
         * If false, the menu item is enabled.
         * 
         */
        "disabled": boolean;
        set(property:"disabled", value: boolean): void;
        get(property:"disabled"): boolean;
        watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "iconClass": string;
        set(property:"iconClass", value: string): void;
        get(property:"iconClass"): string;
        watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Menu text as HTML
         * 
         */
        "label": string;
        set(property:"label", value: string): void;
        get(property:"label"): string;
        watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "role": string;
        set(property:"role", value: string): void;
        get(property:"role"): string;
        watch(property:"role", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Single character (underlined when the parent Menu is focused) used to navigate directly to this widget,
         * also known as a mnemonic.
         * This is denoted in the label by surrounding the single character with {}.
         * For example, if label="{F}ile", then shortcutKey="F".
         * 
         */
        "shortcutKey": string;
        set(property:"shortcutKey", value: string): void;
        get(property:"shortcutKey"): string;
        watch(property:"shortcutKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Focus on this MenuItem
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the index of this widget within its container parent.
         * It returns -1 if the parent does not exist, or if the parent
         * is not a dijit/_Container
         * 
         */
        getIndexInParent(): any;
        /**
         * Returns null if this is the last child of the parent,
         * otherwise returns the next element sibling to the "right".
         * 
         */
        getNextSibling(): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns null if this is the first child of the parent,
         * otherwise returns the next element sibling to the "left".
         * 
         */
        getPreviousSibling(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('disabled', bool) instead.
         * 
         * @param disabled             
         */
        setDisabled(disabled: boolean): void;
        /**
         * Deprecated.   Use set('label', ...) instead.
         * 
         * @param content             
         */
        setLabel(content: String): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * User defined function to handle check/uncheck events
         * 
         * @param checked             
         */
        onChange(checked: boolean): void;
        /**
         * User defined function to handle clicks
         * 
         */
        onClick(): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/DialogUnderlay.html
     *
     * A component used to block input behind a dijit/Dialog.
     * 
     * Normally this class should not be instantiated directly, but rather shown and hidden via
     * DialogUnderlay.show() and DialogUnderlay.hide().  And usually the module is not accessed directly
     * at all, since the underlay is shown and hidden by Dialog.DialogLevelManager.
     * 
     * The underlay itself can be styled based on and id:
     * 
     * #myDialog_underlay { background-color:red; }
     * In the case of dijit.Dialog, this id is based on the id of the Dialog,
     * suffixed with _underlay.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class DialogUnderlay extends dijit._Widget implements dijit._TemplatedMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Id of the dialog.... DialogUnderlay's id is based on this id
         * 
         */
        "dialogId": string;
        set(property:"dialogId", value: string): void;
        get(property:"dialogId"): string;
        watch(property:"dialogId", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Hide the underlay.
         * 
         */
        hide(): void;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Show the dialog underlay
         * 
         */
        show(): void;
        /**
         * Display the underlay with the given attributes set.  If the underlay is already displayed,
         * then adjust it's attributes as specified.
         * 
         * @param attrs The parameters to create DialogUnderlay with.             
         * @param zIndex zIndex of the underlay             
         */
        show(attrs: Object, zIndex: number): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.10/dijit/_ConfirmDialogMixin.html
     *
     * Mixin for Dialog/TooltipDialog with OK/Cancel buttons.
     * 
     */
    class _ConfirmDialogMixin extends dijit._WidgetsInTemplateMixin {
        constructor();
        /**
         * 
         */
        "actionBarTemplate": Object;
        /**
         * Label of cancel button
         * 
         */
        "buttonCancel": string;
        /**
         * Label of OK button
         * 
         */
        "buttonOk": string;
        /**
         * Used to provide a context require to the dojo/parser in order to be
         * able to use relative MIDs (e.g. ./Widget) in the widget's template.
         * 
         */
        "contextRequire": Function;
        /**
         * Should we parse the template to find widgets that might be
         * declared in markup inside it?  (Remove for 2.0 and assume true)
         * 
         */
        "widgetsInTemplate": boolean;
        /**
         * 
         */
        startup(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.10/dijit/ConfirmDialog.html
     *
     * A Dialog with OK/Cancel buttons.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class ConfirmDialog extends dijit.Dialog implements dijit._ConfirmDialogMixin {
        constructor(params: Object, srcNodeRef?: HTMLElement);
        okButton: dijit.form.Button;
        cancelButon: dijit.form.Button;

        /**
         * HTML snippet to show the action bar (gray bar with OK/cancel buttons).
         * Blank by default, but used by ConfirmDialog/ConfirmTooltipDialog subclasses.
         * 
         */
        "actionBarTemplate": string;
        set(property:"actionBarTemplate", value: string): void;
        get(property:"actionBarTemplate"): string;
        watch(property:"actionBarTemplate", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A Toggle to modify the default focus behavior of a Dialog, which
         * is to focus on the first dialog element after opening the dialog.
         * False will disable autofocusing. Default: true
         * 
         */
        "autofocus": boolean;
        set(property:"autofocus", value: boolean): void;
        get(property:"autofocus"): boolean;
        watch(property:"autofocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Label of cancel button
         * 
         */
        "buttonCancel": string;
        set(property:"buttonCancel", value: string): void;
        get(property:"buttonCancel"): string;
        watch(property:"buttonCancel", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Label of OK button
         * 
         */
        "buttonOk": string;
        set(property:"buttonOk", value: string): void;
        get(property:"buttonOk"): string;
        watch(property:"buttonOk", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Dialog show [x] icon to close itself, and ESC key will close the dialog.
         * 
         */
        "closable": boolean;
        set(property:"closable", value: boolean): void;
        get(property:"closable"): boolean;
        watch(property:"closable", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * The innerHTML of the ContentPane.
         * Note that the initialization parameter / argument to set("content", ...)
         * can be a String, DomNode, Nodelist, or _Widget.
         * 
         */
        "content": string;
        set(property:"content", value: string): void;
        get(property:"content"): string;
        watch(property:"content", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Used to provide a context require to the dojo/parser in order to be
         * able to use relative MIDs (e.g. ./Widget) in the widget's template.
         * 
         */
        "contextRequire": Function;
        set(property:"contextRequire", value: Function): void;
        get(property:"contextRequire"): Function;
        watch(property:"contextRequire", callback:{(property?:string, oldValue?:Function, newValue?: Function):void}) :{unwatch():void}
        /**
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         * 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;
        set(property:"doLayout", value: boolean): void;
        get(property:"doLayout"): boolean;
        watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Toggles the movable aspect of the Dialog. If true, Dialog
         * can be dragged by it's title. If false it will remain centered
         * in the viewport.
         * 
         */
        "draggable": boolean;
        set(property:"draggable", value: boolean): void;
        get(property:"draggable"): boolean;
        watch(property:"draggable", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The time in milliseconds it takes the dialog to fade in and out
         * 
         */
        "duration": number;
        set(property:"duration", value: number): void;
        get(property:"duration"): number;
        watch(property:"duration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * Message that shows if an error occurs
         * 
         */
        "errorMessage": string;
        set(property:"errorMessage", value: string): void;
        get(property:"errorMessage"): string;
        watch(property:"errorMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Extract visible content from inside of <body> .... </body>.
         * I.e., strip <html> and <head> (and it's contents) from the href
         * 
         */
        "extractContent": boolean;
        set(property:"extractContent", value: boolean): void;
        get(property:"extractContent"): boolean;
        watch(property:"extractContent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The href of the content that displays now.
         * Set this at construction if you want to load data externally when the
         * pane is shown.  (Set preload=true to load it immediately.)
         * Changing href after creation doesn't have any effect; Use set('href', ...);
         * 
         */
        "href": string;
        set(property:"href", value: string): void;
        get(property:"href"): string;
        watch(property:"href", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Parameters to pass to xhrGet() request, for example:
         * 
         * <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
         * 
         */
        "ioArgs": Object;
        set(property:"ioArgs", value: Object): void;
        get(property:"ioArgs"): Object;
        watch(property:"ioArgs", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Indicates that this widget will call resize() on it's child widgets
         * when they become visible.
         * 
         */
        "isLayoutContainer": boolean;
        set(property:"isLayoutContainer", value: boolean): void;
        get(property:"isLayoutContainer"): boolean;
        watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if the ContentPane has data in it, either specified
         * during initialization (via href or inline content), or set
         * via set('content', ...) / set('href', ...)
         * 
         * False if it doesn't have any content, or if ContentPane is
         * still in the process of downloading href.
         * 
         */
        "isLoaded": boolean;
        set(property:"isLoaded", value: boolean): void;
        get(property:"isLoaded"): boolean;
        watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Message that shows while downloading
         * 
         */
        "loadingMessage": string;
        set(property:"loadingMessage", value: string): void;
        get(property:"loadingMessage"): string;
        watch(property:"loadingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Maximum size to allow the dialog to expand to, relative to viewport size
         * 
         */
        "maxRatio": number;
        set(property:"maxRatio", value: number): void;
        get(property:"maxRatio"): number;
        watch(property:"maxRatio", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * This is the dojo.Deferred returned by set('href', ...) and refresh().
         * Calling onLoadDeferred.then() registers your
         * callback to be called only once, when the prior set('href', ...) call or
         * the initial href parameter to the constructor finishes loading.
         * 
         * This is different than an onLoad() handler which gets called any time any href
         * or content is loaded.
         * 
         */
        "onLoadDeferred": Object;
        set(property:"onLoadDeferred", value: Object): void;
        get(property:"onLoadDeferred"): Object;
        watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * True if Dialog is currently displayed on screen.
         * 
         */
        "open": boolean;
        set(property:"open", value: boolean): void;
        get(property:"open"): boolean;
        watch(property:"open", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Parse content and create the widgets, if any.
         * 
         */
        "parseOnLoad": boolean;
        set(property:"parseOnLoad", value: boolean): void;
        get(property:"parseOnLoad"): boolean;
        watch(property:"parseOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 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 compatibility
         * reasons defaults to dojo._scopeName (which is "dojo" except when
         * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
         * 
         */
        "parserScope": string;
        set(property:"parserScope", value: string): void;
        get(property:"parserScope"): string;
        watch(property:"parserScope", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Force load of data on initialization even if pane is hidden.
         * 
         */
        "preload": boolean;
        set(property:"preload", value: boolean): void;
        get(property:"preload"): boolean;
        watch(property:"preload", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Prevent caching of data from href's by appending a timestamp to the href.
         * 
         */
        "preventCache": boolean;
        set(property:"preventCache", value: boolean): void;
        get(property:"preventCache"): boolean;
        watch(property:"preventCache", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A Toggle to modify the default focus behavior of a Dialog, which
         * is to re-focus the element which had focus before being opened.
         * False will disable refocusing. Default: true
         * 
         */
        "refocus": boolean;
        set(property:"refocus", value: boolean): void;
        get(property:"refocus"): boolean;
        watch(property:"refocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Refresh (re-download) content when pane goes from hidden to shown
         * 
         */
        "refreshOnShow": boolean;
        set(property:"refreshOnShow", value: boolean): void;
        get(property:"refreshOnShow"): boolean;
        watch(property:"refreshOnShow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Will be "Error" if one or more of the child widgets has an invalid value,
         * "Incomplete" if not all of the required child widgets are filled in.  Otherwise, "",
         * which indicates that the form is ready to be submitted.
         * 
         */
        "state": string;
        set(property:"state", value: string): void;
        get(property:"state"): string;
        watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "stopParser": boolean;
        set(property:"stopParser", value: boolean): void;
        get(property:"stopParser"): boolean;
        watch(property:"stopParser", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Should we parse the template to find widgets that might be
         * declared in markup inside it?  (Remove for 2.0 and assume true)
         * 
         */
        "widgetsInTemplate": boolean;
        set(property:"widgetsInTemplate", value: boolean): void;
        get(property:"widgetsInTemplate"): boolean;
        watch(property:"widgetsInTemplate", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Makes the given widget a child of this widget.
         * Inserts specified child widget's dom node as a child of this widget's
         * container node, and possibly does other processing (such as layout).
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Cancels an in-flight download of content
         * 
         */
        cancel(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * You can call this function directly, ex. in the event that you
         * programmatically add a widget to the form after the form has been
         * initialized.
         * 
         * @param inStartup             
         */
        connectChildren(inStartup: boolean): void;
        /**
         * 
         * @param params             
         * @param srcNodeRef             
         */
        create(params: any, srcNodeRef: any): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Destroy all the widgets inside the ContentPane and empty containerNode
         * 
         * @param preserveDom             
         */
        destroyDescendants(preserveDom: boolean): void;
        /**
         * Destroy the ContentPane and its contents
         * 
         * @param preserveDom             
         */
        destroyRecursive(preserveDom: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Deprecated method.   Applications no longer need to call this.   Remove for 2.0.
         * 
         */
        disconnectChildren(): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Callback when the user hits the submit button.
         * Override this method to handle Dialog execution.
         * After the user has pressed the submit button, the Dialog
         * first calls onExecute() to notify the container to hide the
         * dialog and restore focus to wherever it used to be.
         * 
         * Then this method is called.
         * 
         * @param formContents             
         */
        execute(formContents: Object): void;
        /**
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * 
         */
        getValues(): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Hide the dialog
         * 
         */
        hide(): any;
        /**
         * Function that should grab the content specified via href.
         * 
         * @param args An object with the following properties:handleAs (String, optional): Acceptable values are: text (default), json, json-comment-optional,json-comment-filtered, javascript, xml. See dojo/_base/xhr.contentHandlerssync (Boolean, optional): false is default. Indicates whether the request shouldbe a synchronous (blocking) request.headers (Object, optional): Additional HTTP headers to send in the request.failOk (Boolean, optional): false is default. Indicates whether a request should beallowed to fail (and therefore no console error message inthe event of a failure)contentType (String|Boolean): "application/x-www-form-urlencoded" is default. Set to false toprevent a Content-Type header from being sent, or to a stringto send a different Content-Type.load: This function will becalled on a successful HTTP response code.error: This function willbe called when the request fails due to a network or server error, the urlis invalid, etc. It will also be called if the load or handle callback throws anexception, unless djConfig.debugAtAllCosts is true.  This allows deployed applicationsto continue to run even when a logic error happens in the callback, while makingit easier to troubleshoot while in debug mode.handle: This function willbe called at the end of every request, whether or not an error occurs.url (String): URL to server endpoint.content (Object, optional): Contains properties with string values. Theseproperties will be serialized as name1=value2 andpassed in the request.timeout (Integer, optional): Milliseconds to wait for the response. If this timepasses, the then error callbacks are called.form (DOMNode, optional): DOM node for a form. Used to extract the form valuesand send to the server.preventCache (Boolean, optional): Default is false. If true, then a"dojo.preventCache" parameter is sent in the requestwith a value that changes with each request(timestamp). Useful only with GET-type requests.rawBody (String, optional): Sets the raw body for an HTTP request. If this is used, then the contentproperty is ignored. This is mostly useful for HTTP methods that havea body to their requests, like PUT or POST. This property can be used insteadof postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.ioPublish (Boolean, optional): Set this explicitly to false to prevent publishing of topics related toIO operations. Otherwise, if djConfig.ioPublish is set to true, topicswill be published via dojo/topic.publish() for different phases of an IO operation.See dojo/main.__IoPublish for a list of topics that are published.            
         */
        ioMethod(args: Object): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * Returns true if all of the widgets are valid.
         * Deprecated, will be removed in 2.0.  Use get("state") instead.
         * 
         */
        isValid: {(): boolean};
        /**
         * 
         * @param params             
         * @param node             
         * @param ctor             
         */
        markupFactory(params: any, node: any, ctor: any): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, DocumentFragment, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, DocumentFragment, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, DocumentFragment, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference:  dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, DocumentFragment, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, DocumentFragment, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, DocumentFragment, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference:  dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * 
         */
        postMixInProperties(): void;
        /**
         * [Re]download contents of href and display
         * cancels any currently in-flight requests
         * posts "loading..." message
         * sends XHR to download new data
         * 
         */
        refresh(): any;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * 
         */
        reset(): void;
        /**
         * See dijit/layout/_LayoutWidget.resize() for description.
         * Although ContentPane doesn't extend _LayoutWidget, it does implement
         * the same API.
         * 
         * @param changeSize             
         * @param resultSize             
         */
        resize(changeSize: any, resultSize: any): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: String): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: HTMLElement): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: NodeList): void;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: String): any;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: URL): any;
        /**
         * 
         * @param val             
         */
        setValues(val: any): any;
        /**
         * Display the dialog
         * 
         */
        show(): any;
        /**
         * Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * returns if the form is valid - same as isValid - but
         * provides a few additional (ui-specific) features:
         * 
         * it will highlight any sub-widgets that are not valid
         * it will call focus() on the first invalid sub-widget
         * 
         */
        validate(): any;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Called when user has pressed the Dialog's cancel button, to notify container.
         * Developer shouldn't override or connect to this method;
         * it's a private communication device between the TooltipDialog
         * and the thing that opened it (ex: dijit/form/DropDownButton)
         * 
         */
        onCancel(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * 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.
         * 
         * @param error             
         */
        onContentError(error: Error): void;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when download is finished.
         * 
         */
        onDownloadEnd(): 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.
         * 
         * @param error             
         */
        onDownloadError(error: Error): any;
        /**
         * Called before download starts.
         * The string returned by this function will be the html
         * that tells the user we are loading something.
         * Override with your own function if you want to change text.
         * 
         */
        onDownloadStart(): any;
        /**
         * Called when user has pressed the dialog's OK button, to notify container.
         * Developer shouldn't override or connect to this method;
         * it's a private communication device between the TooltipDialog
         * and the thing that opened it (ex: dijit/form/DropDownButton)
         * 
         */
        onExecute(): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Event hook, is called after everything is loaded and widgetified
         * 
         * @param data             
         */
        onLoad(data: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
        /**
         * Event hook, is called before old content is cleared
         * 
         */
        onUnload(): void;
        /**
         * Stub function to connect to if you want to do something
         * (like disable/enable a submit button) when the valid
         * state changes on the form as a whole.
         * 
         * Deprecated.  Will be removed in 2.0.  Use watch("state", ...) instead.
         * 
         * @param isValid             
         */
        onValidStateChange(isValid: boolean): void;
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Dialog.html
     *
     * A modal dialog Widget.
     * Pops up a modal dialog window, blocking access to the screen
     * and also graying out the screen Dialog is extended from
     * ContentPane so it supports all the same parameters (href, etc.).
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class Dialog extends dijit.layout.ContentPane implements dijit._TemplatedMixin, dijit.form._FormMixin, dijit._DialogMixin, dijit._CssStateMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A Toggle to modify the default focus behavior of a Dialog, which
         * is to focus on the first dialog element after opening the dialog.
         * False will disable autofocusing. Default: true
         * 
         */
        "autofocus": boolean;
        set(property:"autofocus", value: boolean): void;
        get(property:"autofocus"): boolean;
        watch(property:"autofocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Dialog show [x] icon to close itself, and ESC key will close the dialog.
         * 
         */
        "closable": boolean;
        set(property:"closable", value: boolean): void;
        get(property:"closable"): boolean;
        watch(property:"closable", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * The innerHTML of the ContentPane.
         * Note that the initialization parameter / argument to set("content", ...)
         * can be a String, DomNode, Nodelist, or _Widget.
         * 
         */
        "content": string;
        set(property:"content", value: string): void;
        get(property:"content"): string;
        watch(property:"content", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         * 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;
        set(property:"doLayout", value: boolean): void;
        get(property:"doLayout"): boolean;
        watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Toggles the movable aspect of the Dialog. If true, Dialog
         * can be dragged by it's title. If false it will remain centered
         * in the viewport.
         * 
         */
        "draggable": boolean;
        set(property:"draggable", value: boolean): void;
        get(property:"draggable"): boolean;
        watch(property:"draggable", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The time in milliseconds it takes the dialog to fade in and out
         * 
         */
        "duration": number;
        set(property:"duration", value: number): void;
        get(property:"duration"): number;
        watch(property:"duration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * Message that shows if an error occurs
         * 
         */
        "errorMessage": string;
        set(property:"errorMessage", value: string): void;
        get(property:"errorMessage"): string;
        watch(property:"errorMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Extract visible content from inside of <body> .... </body>.
         * I.e., strip <html> and <head> (and it's contents) from the href
         * 
         */
        "extractContent": boolean;
        set(property:"extractContent", value: boolean): void;
        get(property:"extractContent"): boolean;
        watch(property:"extractContent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The href of the content that displays now.
         * Set this at construction if you want to load data externally when the
         * pane is shown.  (Set preload=true to load it immediately.)
         * Changing href after creation doesn't have any effect; Use set('href', ...);
         * 
         */
        "href": string;
        set(property:"href", value: string): void;
        get(property:"href"): string;
        watch(property:"href", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Parameters to pass to xhrGet() request, for example:
         * 
         * <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
         * 
         */
        "ioArgs": Object;
        set(property:"ioArgs", value: Object): void;
        get(property:"ioArgs"): Object;
        watch(property:"ioArgs", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Indicates that this widget will call resize() on it's child widgets
         * when they become visible.
         * 
         */
        "isLayoutContainer": boolean;
        set(property:"isLayoutContainer", value: boolean): void;
        get(property:"isLayoutContainer"): boolean;
        watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if the ContentPane has data in it, either specified
         * during initialization (via href or inline content), or set
         * via set('content', ...) / set('href', ...)
         * 
         * False if it doesn't have any content, or if ContentPane is
         * still in the process of downloading href.
         * 
         */
        "isLoaded": boolean;
        set(property:"isLoaded", value: boolean): void;
        get(property:"isLoaded"): boolean;
        watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Message that shows while downloading
         * 
         */
        "loadingMessage": string;
        set(property:"loadingMessage", value: string): void;
        get(property:"loadingMessage"): string;
        watch(property:"loadingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Maximum size to allow the dialog to expand to, relative to viewport size
         * 
         */
        "maxRatio": number;
        set(property:"maxRatio", value: number): void;
        get(property:"maxRatio"): number;
        watch(property:"maxRatio", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * This is the dojo.Deferred returned by set('href', ...) and refresh().
         * Calling onLoadDeferred.then() registers your
         * callback to be called only once, when the prior set('href', ...) call or
         * the initial href parameter to the constructor finishes loading.
         * 
         * This is different than an onLoad() handler which gets called any time any href
         * or content is loaded.
         * 
         */
        "onLoadDeferred": Object;
        set(property:"onLoadDeferred", value: Object): void;
        get(property:"onLoadDeferred"): Object;
        watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * True if Dialog is currently displayed on screen.
         * 
         */
        "open": boolean;
        set(property:"open", value: boolean): void;
        get(property:"open"): boolean;
        watch(property:"open", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Parse content and create the widgets, if any.
         * 
         */
        "parseOnLoad": boolean;
        set(property:"parseOnLoad", value: boolean): void;
        get(property:"parseOnLoad"): boolean;
        watch(property:"parseOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 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 compatibility
         * reasons defaults to dojo._scopeName (which is "dojo" except when
         * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
         * 
         */
        "parserScope": string;
        set(property:"parserScope", value: string): void;
        get(property:"parserScope"): string;
        watch(property:"parserScope", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Force load of data on initialization even if pane is hidden.
         * 
         */
        "preload": boolean;
        set(property:"preload", value: boolean): void;
        get(property:"preload"): boolean;
        watch(property:"preload", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Prevent caching of data from href's by appending a timestamp to the href.
         * 
         */
        "preventCache": boolean;
        set(property:"preventCache", value: boolean): void;
        get(property:"preventCache"): boolean;
        watch(property:"preventCache", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A Toggle to modify the default focus behavior of a Dialog, which
         * is to re-focus the element which had focus before being opened.
         * False will disable refocusing. Default: true
         * 
         */
        "refocus": boolean;
        set(property:"refocus", value: boolean): void;
        get(property:"refocus"): boolean;
        watch(property:"refocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Refresh (re-download) content when pane goes from hidden to shown
         * 
         */
        "refreshOnShow": boolean;
        set(property:"refreshOnShow", value: boolean): void;
        get(property:"refreshOnShow"): boolean;
        watch(property:"refreshOnShow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Will be "Error" if one or more of the child widgets has an invalid value,
         * "Incomplete" if not all of the required child widgets are filled in.  Otherwise, "",
         * which indicates that the form is ready to be submitted.
         * 
         */
        "state": string;
        set(property:"state", value: string): void;
        get(property:"state"): string;
        watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "stopParser": boolean;
        set(property:"stopParser", value: boolean): void;
        get(property:"stopParser"): boolean;
        watch(property:"stopParser", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Makes the given widget a child of this widget.
         * Inserts specified child widget's dom node as a child of this widget's
         * container node, and possibly does other processing (such as layout).
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Cancels an in-flight download of content
         * 
         */
        cancel(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * You can call this function directly, ex. in the event that you
         * programmatically add a widget to the form after the form has been
         * initialized.
         * 
         * @param inStartup             
         */
        connectChildren(inStartup: boolean): void;
        /**
         * 
         * @param params             
         * @param srcNodeRef             
         */
        create(params: any, srcNodeRef: any): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Destroy all the widgets inside the ContentPane and empty containerNode
         * 
         * @param preserveDom             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy the ContentPane and its contents
         * 
         * @param preserveDom             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Deprecated method.   Applications no longer need to call this.   Remove for 2.0.
         * 
         */
        disconnectChildren(): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Callback when the user hits the submit button.
         * Override this method to handle Dialog execution.
         * After the user has pressed the submit button, the Dialog
         * first calls onExecute() to notify the container to hide the
         * dialog and restore focus to wherever it used to be.
         * 
         * Then this method is called.
         * 
         * @param formContents             
         */
        execute(formContents: Object): void;
        /**
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * 
         */
        getValues(): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Hide the dialog
         * 
         */
        hide(): any;
        /**
         * Function that should grab the content specified via href.
         * 
         * @param args An object with the following properties:handleAs (String, optional): Acceptable values are: text (default), json, json-comment-optional,json-comment-filtered, javascript, xml. See dojo/_base/xhr.contentHandlerssync (Boolean, optional): false is default. Indicates whether the request shouldbe a synchronous (blocking) request.headers (Object, optional): Additional HTTP headers to send in the request.failOk (Boolean, optional): false is default. Indicates whether a request should beallowed to fail (and therefore no console error message inthe event of a failure)contentType (String|Boolean): "application/x-www-form-urlencoded" is default. Set to false toprevent a Content-Type header from being sent, or to a stringto send a different Content-Type.load: This function will becalled on a successful HTTP response code.error: This function willbe called when the request fails due to a network or server error, the urlis invalid, etc. It will also be called if the load or handle callback throws anexception, unless djConfig.debugAtAllCosts is true.  This allows deployed applicationsto continue to run even when a logic error happens in the callback, while makingit easier to troubleshoot while in debug mode.handle: This function willbe called at the end of every request, whether or not an error occurs.url (String): URL to server endpoint.content (Object, optional): Contains properties with string values. Theseproperties will be serialized as name1=value2 andpassed in the request.timeout (Integer, optional): Milliseconds to wait for the response. If this timepasses, the then error callbacks are called.form (DOMNode, optional): DOM node for a form. Used to extract the form valuesand send to the server.preventCache (Boolean, optional): Default is false. If true, then a"dojo.preventCache" parameter is sent in the requestwith a value that changes with each request(timestamp). Useful only with GET-type requests.rawBody (String, optional): Sets the raw body for an HTTP request. If this is used, then the contentproperty is ignored. This is mostly useful for HTTP methods that havea body to their requests, like PUT or POST. This property can be used insteadof postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.ioPublish (Boolean, optional): Set this explicitly to false to prevent publishing of topics related toIO operations. Otherwise, if djConfig.ioPublish is set to true, topicswill be published via dojo/topic.publish() for different phases of an IO operation.See dojo/main.__IoPublish for a list of topics that are published.            
         */
        ioMethod(args: Object): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * Returns true if all of the widgets are valid.
         * Deprecated, will be removed in 2.0.  Use get("state") instead.
         * 
         */
        isValid: {(): boolean};
        /**
         * 
         * @param params             
         * @param node             
         * @param ctor             
         */
        markupFactory(params: any, node: any, ctor: any): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * 
         */
        postMixInProperties(): void;
        /**
         * [Re]download contents of href and display
         * cancels any currently in-flight requests
         * posts "loading..." message
         * sends XHR to download new data
         * 
         */
        refresh(): any;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * 
         */
        reset(): void;
        /**
         * See dijit/layout/_LayoutWidget.resize() for description.
         * Although ContentPane doesn't extend _LayoutWidget, it does implement
         * the same API.
         * 
         * @param changeSize             
         * @param resultSize             
         */
        resize(changeSize: any, resultSize: any): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: String): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: HTMLElement): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: NodeList): void;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: String): any;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: URL): any;
        /**
         * 
         * @param val             
         */
        setValues(val: any): any;
        /**
         * Display the dialog
         * 
         */
        show(): any;
        /**
         * Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * returns if the form is valid - same as isValid - but
         * provides a few additional (ui-specific) features:
         * 
         * it will highlight any sub-widgets that are not valid
         * it will call focus() on the first invalid sub-widget
         * 
         */
        validate(): any;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Called when user has pressed the Dialog's cancel button, to notify container.
         * Developer shouldn't override or connect to this method;
         * it's a private communication device between the TooltipDialog
         * and the thing that opened it (ex: dijit/form/DropDownButton)
         * 
         */
        onCancel(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * 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.
         * 
         * @param error             
         */
        onContentError(error: Error): void;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when download is finished.
         * 
         */
        onDownloadEnd(): 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.
         * 
         * @param error             
         */
        onDownloadError(error: Error): any;
        /**
         * Called before download starts.
         * The string returned by this function will be the html
         * that tells the user we are loading something.
         * Override with your own function if you want to change text.
         * 
         */
        onDownloadStart(): any;
        /**
         * Called when user has pressed the dialog's OK button, to notify container.
         * Developer shouldn't override or connect to this method;
         * it's a private communication device between the TooltipDialog
         * and the thing that opened it (ex: dijit/form/DropDownButton)
         * 
         */
        onExecute(): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Event hook, is called after everything is loaded and widgetified
         * 
         * @param data             
         */
        onLoad(data: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
        /**
         * Event hook, is called before old content is cleared
         * 
         */
        onUnload(): void;
        /**
         * Stub function to connect to if you want to do something
         * (like disable/enable a submit button) when the valid
         * state changes on the form as a whole.
         * 
         * Deprecated.  Will be removed in 2.0.  Use watch("state", ...) instead.
         * 
         * @param isValid             
         */
        onValidStateChange(isValid: boolean): void;
    }
    module Dialog {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/Dialog._DialogBase.html
         *
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class _DialogBase extends dijit._TemplatedMixin implements dijit.form._FormMixin, dijit._DialogMixin, dijit._CssStateMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            /**
             * A Toggle to modify the default focus behavior of a Dialog, which
             * is to focus on the first dialog element after opening the dialog.
             * False will disable autofocusing. Default: true
             * 
             */
            "autofocus": boolean;
            /**
             * 
             */
            "baseClass": string;
            /**
             * Dialog show [x] icon to close itself, and ESC key will close the dialog.
             * 
             */
            "closable": boolean;
            /**
             * 
             */
            "cssStateNodes": Object;
            /**
             * Don't change this parameter from the default value.
             * This ContentPane parameter doesn't make sense for Dialog, since Dialog
             * is never a child of a layout container, nor can you specify the size of
             * Dialog in order to control the size of an inner widget.
             * 
             */
            "doLayout": boolean;
            /**
             * Toggles the movable aspect of the Dialog. If true, Dialog
             * can be dragged by it's title. If false it will remain centered
             * in the viewport.
             * 
             */
            "draggable": boolean;
            /**
             * The time in milliseconds it takes the dialog to fade in and out
             * 
             */
            "duration": number;
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            /**
             * Maximum size to allow the dialog to expand to, relative to viewport size
             * 
             */
            "maxRatio": number;
            /**
             * True if Dialog is currently displayed on screen.
             * 
             */
            "open": boolean;
            /**
             * A Toggle to modify the default focus behavior of a Dialog, which
             * is to re-focus the element which had focus before being opened.
             * False will disable refocusing. Default: true
             * 
             */
            "refocus": boolean;
            /**
             * 
             */
            "searchContainerNode": boolean;
            /**
             * Will be "Error" if one or more of the child widgets has an invalid value,
             * "Incomplete" if not all of the required child widgets are filled in.  Otherwise, "",
             * which indicates that the form is ready to be submitted.
             * 
             */
            "state": string;
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            /**
             * 
             */
            "templateString": string;
            /**
             * Construct the UI for this widget from a template, setting this.domNode.
             * 
             */
            buildRendering(): void;
            /**
             * You can call this function directly, ex. in the event that you
             * programmatically add a widget to the form after the form has been
             * initialized.
             * 
             * @param inStartup             
             */
            connectChildren(inStartup: boolean): void;
            /**
             * 
             */
            destroy(): void;
            /**
             * 
             */
            destroyRendering(): void;
            /**
             * Deprecated method.   Applications no longer need to call this.   Remove for 2.0.
             * 
             */
            disconnectChildren(): void;
            /**
             * Callback when the user hits the submit button.
             * Override this method to handle Dialog execution.
             * After the user has pressed the submit button, the Dialog
             * first calls onExecute() to notify the container to hide the
             * dialog and restore focus to wherever it used to be.
             * 
             * Then this method is called.
             * 
             * @param formContents             
             */
            execute(formContents: Object): void;
            /**
             * 
             */
            focus(): void;
            /**
             * 
             */
            getValues(): any;
            /**
             * Hide the dialog
             * 
             */
            hide(): any;
            /**
             * Returns true if all of the widgets are valid.
             * Deprecated, will be removed in 2.0.  Use get("state") instead.
             * 
             */
            isValid: {(): boolean};
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * 
             */
            reset(): void;
            /**
             * 
             * @param val             
             */
            setValues(val: any): any;
            /**
             * Display the dialog
             * 
             */
            show(): any;
            /**
             * 
             */
            startup(): void;
            /**
             * returns if the form is valid - same as isValid - but
             * provides a few additional (ui-specific) features:
             * 
             * it will highlight any sub-widgets that are not valid
             * it will call focus() on the first invalid sub-widget
             * 
             */
            validate(): any;
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when user has pressed the Dialog's cancel button, to notify container.
             * Developer shouldn't override or connect to this method;
             * it's a private communication device between the TooltipDialog
             * and the thing that opened it (ex: dijit/form/DropDownButton)
             * 
             */
            onCancel(): void;
            /**
             * Called when user has pressed the dialog's OK button, to notify container.
             * Developer shouldn't override or connect to this method;
             * it's a private communication device between the TooltipDialog
             * and the thing that opened it (ex: dijit/form/DropDownButton)
             * 
             */
            onExecute(): void;
            /**
             * Called when data has been loaded from an href.
             * Unlike most other callbacks, this function can be connected to (via dojo.connect)
             * but should not be overridden.
             * 
             */
            onLoad(): void;
            /**
             * Stub function to connect to if you want to do something
             * (like disable/enable a submit button) when the valid
             * state changes on the form as a whole.
             * 
             * Deprecated.  Will be removed in 2.0.  Use watch("state", ...) instead.
             * 
             * @param isValid             
             */
            onValidStateChange(isValid: boolean): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/Dialog._DialogLevelManager.html
         *
         * Controls the various active "levels" on the page, starting with the
         * stuff initially visible on the page (at z-index 0), and then having an entry for
         * each Dialog shown.
         * 
         */
        interface _DialogLevelManager {
            /**
             * Called when the specified dialog is hidden/destroyed, after the fade-out
             * animation ends, in order to reset page focus, fix the underlay, etc.
             * If the specified dialog isn't open then does nothing.
             * 
             * Caller is responsible for either setting display:none on the dialog domNode,
             * or calling dijit/popup.hide(), or removing it from the page DOM.
             * 
             * @param dialog             
             */
            hide(dialog: dijit._WidgetBase): void;
            /**
             * Returns true if specified Dialog is the top in the task
             * 
             * @param dialog             
             */
            isTop(dialog: dijit._WidgetBase): boolean;
            /**
             * Call right before fade-in animation for new dialog.
             * Saves current focus, displays/adjusts underlay for new dialog,
             * and sets the z-index of the dialog itself.
             * 
             * New dialog will be displayed on top of all currently displayed dialogs.
             * 
             * Caller is responsible for setting focus in new dialog after the fade-in
             * animation completes.
             * 
             * @param dialog             
             * @param underlayAttrs             
             */
            show(dialog: dijit._WidgetBase, underlayAttrs: Object): void;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/ColorPalette.html
     *
     * A keyboard accessible color-picking widget
     * Grid showing various colors, so the user can pick a certain color.
     * Can be used standalone, or as a popup.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class ColorPalette extends dijit._Widget implements dijit._TemplatedMixin, dijit._PaletteMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * CSS class applied to each cell in the palette
         * 
         */
        "cellClass": string;
        set(property:"cellClass", value: string): void;
        get(property:"cellClass"): string;
        watch(property:"cellClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Number of milliseconds before a held key or button becomes typematic
         * 
         */
        "defaultTimeout": number;
        set(property:"defaultTimeout", value: number): void;
        get(property:"defaultTimeout"): number;
        watch(property:"defaultTimeout", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Constructor for Object created for each cell of the palette.
         * dyeClass should implement the dijit/_PaletteMixin.__Dye interface.
         * 
         */
        "dyeClass": Function;
        set(property:"dyeClass", value: Function): void;
        get(property:"dyeClass"): Function;
        watch(property:"dyeClass", callback:{(property?:string, oldValue?:Function, newValue?: Function):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Size of grid, either "7x10" or "3x4".
         * 
         */
        "palette": string;
        set(property:"palette", value: string): void;
        get(property:"palette"): string;
        watch(property:"palette", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Widget tab index.
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The template of this widget.
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Fraction of time used to change the typematic timer between events
         * 1.0 means that each typematic event fires at defaultTimeout intervals
         * Less than 1.0 means that each typematic event fires at an increasing faster rate
         * 
         */
        "timeoutChangeRate": number;
        set(property:"timeoutChangeRate", value: number): void;
        get(property:"timeoutChangeRate"): number;
        watch(property:"timeoutChangeRate", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Currently selected color/emoticon/etc.
         * 
         */
        "value": string;
        set(property:"value", value: string): void;
        get(property:"value"): string;
        watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Focus this widget.  Puts focus on the most recently focused cell.
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Callback when a cell is selected.
         * 
         * @param value Value corresponding to cell.             
         */
        onChange(value: String): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    module ColorPalette {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/ColorPalette._Color.html
         *
         * Object associated with each cell in a ColorPalette palette.
         * Implements dijit/Dye.
         * 
         * @param alias English name of the color.     
         * @param row Vertical position in grid.     
         * @param col     
         * @param title Localized name of the color.     
         */
        class _Color extends dojo._base.Color {
            constructor(alias: String, row: number, col: any, title: String);
            /**
             * 
             */
            "a": number;
            /**
             * 
             */
            "b": number;
            /**
             * 
             */
            "g": number;
            /**
             * 
             */
            "hcTemplate": string;
            /**
             * 
             */
            "r": number;
            /**
             * 
             */
            "template": string;
            /**
             * 
             * @param cell             
             * @param blankGif             
             */
            fillCell(cell: HTMLElement, blankGif: String): void;
            /**
             * Note that although dijit._Color is initialized with a value like "white" getValue() always
             * returns a hex value
             * 
             */
            getValue(): any;
            /**
             * makes sure that the object has correct attributes
             * 
             */
            sanitize(): void;
            /**
             * Takes a named string, hex string, array of rgb or rgba values,
             * an object with r, g, b, and a properties, or another Color object
             * and sets this color instance to that value.
             * 
             * @param color             
             */
            setColor(color: any[]): Function;
            /**
             * Takes a named string, hex string, array of rgb or rgba values,
             * an object with r, g, b, and a properties, or another Color object
             * and sets this color instance to that value.
             * 
             * @param color             
             */
            setColor(color: String): Function;
            /**
             * Takes a named string, hex string, array of rgb or rgba values,
             * an object with r, g, b, and a properties, or another Color object
             * and sets this color instance to that value.
             * 
             * @param color             
             */
            setColor(color: Object): Function;
            /**
             * Returns a css color string in rgb(a) representation
             * 
             * @param includeAlpha               Optional            
             */
            toCss(includeAlpha: boolean): String;
            /**
             * Returns a CSS color string in hexadecimal representation
             * 
             */
            toHex(): String;
            /**
             * Returns 3 component array of rgb values
             * 
             */
            toRgb(): any[];
            /**
             * Returns a 4 component array of rgba values from the color
             * represented by this object.
             * 
             */
            toRgba(): any[];
            /**
             * Returns a visual representation of the color
             * 
             */
            toString(): any;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Fieldset.html
     *
     * An accessible fieldset that can be expanded or collapsed via
     * its legend.  Fieldset extends dijit.TitlePane.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class Fieldset extends dijit.TitlePane {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * The root className to use for the various states of this widget
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * The innerHTML of the ContentPane.
         * Note that the initialization parameter / argument to set("content", ...)
         * can be a String, DomNode, Nodelist, or _Widget.
         * 
         */
        "content": string;
        set(property:"content", value: string): void;
        get(property:"content"): string;
        watch(property:"content", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Don't change this parameter from the default value.
         * This ContentPane parameter doesn't make sense for TitlePane, since TitlePane
         * is never a child of a layout container, nor should TitlePane try to control
         * the size of an inner widget.
         * 
         */
        "doLayout": boolean;
        set(property:"doLayout", value: boolean): void;
        get(property:"doLayout"): boolean;
        watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Time in milliseconds to fade in/fade out
         * 
         */
        "duration": number;
        set(property:"duration", value: number): void;
        get(property:"duration"): number;
        watch(property:"duration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * Message that shows if an error occurs
         * 
         */
        "errorMessage": string;
        set(property:"errorMessage", value: string): void;
        get(property:"errorMessage"): string;
        watch(property:"errorMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Extract visible content from inside of <body> .... </body>.
         * I.e., strip <html> and <head> (and it's contents) from the href
         * 
         */
        "extractContent": boolean;
        set(property:"extractContent", value: boolean): void;
        get(property:"extractContent"): boolean;
        watch(property:"extractContent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The href of the content that displays now.
         * Set this at construction if you want to load data externally when the
         * pane is shown.  (Set preload=true to load it immediately.)
         * Changing href after creation doesn't have any effect; Use set('href', ...);
         * 
         */
        "href": string;
        set(property:"href", value: string): void;
        get(property:"href"): string;
        watch(property:"href", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Parameters to pass to xhrGet() request, for example:
         * 
         * <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
         * 
         */
        "ioArgs": Object;
        set(property:"ioArgs", value: Object): void;
        get(property:"ioArgs"): Object;
        watch(property:"ioArgs", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Indicates that this widget will call resize() on it's child widgets
         * when they become visible.
         * 
         */
        "isLayoutContainer": boolean;
        set(property:"isLayoutContainer", value: boolean): void;
        get(property:"isLayoutContainer"): boolean;
        watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if the ContentPane has data in it, either specified
         * during initialization (via href or inline content), or set
         * via set('content', ...) / set('href', ...)
         * 
         * False if it doesn't have any content, or if ContentPane is
         * still in the process of downloading href.
         * 
         */
        "isLoaded": boolean;
        set(property:"isLoaded", value: boolean): void;
        get(property:"isLoaded"): boolean;
        watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Message that shows while downloading
         * 
         */
        "loadingMessage": string;
        set(property:"loadingMessage", value: string): void;
        get(property:"loadingMessage"): string;
        watch(property:"loadingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is the dojo.Deferred returned by set('href', ...) and refresh().
         * Calling onLoadDeferred.then() registers your
         * callback to be called only once, when the prior set('href', ...) call or
         * the initial href parameter to the constructor finishes loading.
         * 
         * This is different than an onLoad() handler which gets called any time any href
         * or content is loaded.
         * 
         */
        "onLoadDeferred": Object;
        set(property:"onLoadDeferred", value: Object): void;
        get(property:"onLoadDeferred"): Object;
        watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Whether fieldset is opened or closed.
         * 
         */
        "open": boolean;
        set(property:"open", value: boolean): void;
        get(property:"open"): boolean;
        watch(property:"open", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Parse content and create the widgets, if any.
         * 
         */
        "parseOnLoad": boolean;
        set(property:"parseOnLoad", value: boolean): void;
        get(property:"parseOnLoad"): boolean;
        watch(property:"parseOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 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 compatibility
         * reasons defaults to dojo._scopeName (which is "dojo" except when
         * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
         * 
         */
        "parserScope": string;
        set(property:"parserScope", value: string): void;
        get(property:"parserScope"): string;
        watch(property:"parserScope", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Force load of data on initialization even if pane is hidden.
         * 
         */
        "preload": boolean;
        set(property:"preload", value: boolean): void;
        get(property:"preload"): boolean;
        watch(property:"preload", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Prevent caching of data from href's by appending a timestamp to the href.
         * 
         */
        "preventCache": boolean;
        set(property:"preventCache", value: boolean): void;
        get(property:"preventCache"): boolean;
        watch(property:"preventCache", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Refresh (re-download) content when pane goes from hidden to shown
         * 
         */
        "refreshOnShow": boolean;
        set(property:"refreshOnShow", value: boolean): void;
        get(property:"refreshOnShow"): boolean;
        watch(property:"refreshOnShow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * 
         */
        "stopParser": boolean;
        set(property:"stopParser", value: boolean): void;
        get(property:"stopParser"): boolean;
        watch(property:"stopParser", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Tabindex setting for the title (so users can tab to the title then
         * use space/enter to open/close the title pane)
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Content of the legend tag. Overrides  tag if not empty.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Whether pane can be opened or closed by clicking the title bar.
         * 
         */
        "toggleable": boolean;
        set(property:"toggleable", value: boolean): void;
        get(property:"toggleable"): boolean;
        watch(property:"toggleable", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Makes the given widget a child of this widget.
         * Inserts specified child widget's dom node as a child of this widget's
         * container node, and possibly does other processing (such as layout).
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Cancels an in-flight download of content
         * 
         */
        cancel(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * 
         * @param params             
         * @param srcNodeRef             
         */
        create(params: any, srcNodeRef: any): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Destroy all the widgets inside the ContentPane and empty containerNode
         * 
         * @param preserveDom             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy the ContentPane and its contents
         * 
         * @param preserveDom             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Function that should grab the content specified via href.
         * 
         * @param args An object with the following properties:handleAs (String, optional): Acceptable values are: text (default), json, json-comment-optional,json-comment-filtered, javascript, xml. See dojo/_base/xhr.contentHandlerssync (Boolean, optional): false is default. Indicates whether the request shouldbe a synchronous (blocking) request.headers (Object, optional): Additional HTTP headers to send in the request.failOk (Boolean, optional): false is default. Indicates whether a request should beallowed to fail (and therefore no console error message inthe event of a failure)contentType (String|Boolean): "application/x-www-form-urlencoded" is default. Set to false toprevent a Content-Type header from being sent, or to a stringto send a different Content-Type.load: This function will becalled on a successful HTTP response code.error: This function willbe called when the request fails due to a network or server error, the urlis invalid, etc. It will also be called if the load or handle callback throws anexception, unless djConfig.debugAtAllCosts is true.  This allows deployed applicationsto continue to run even when a logic error happens in the callback, while makingit easier to troubleshoot while in debug mode.handle: This function willbe called at the end of every request, whether or not an error occurs.url (String): URL to server endpoint.content (Object, optional): Contains properties with string values. Theseproperties will be serialized as name1=value2 andpassed in the request.timeout (Integer, optional): Milliseconds to wait for the response. If this timepasses, the then error callbacks are called.form (DOMNode, optional): DOM node for a form. Used to extract the form valuesand send to the server.preventCache (Boolean, optional): Default is false. If true, then a"dojo.preventCache" parameter is sent in the requestwith a value that changes with each request(timestamp). Useful only with GET-type requests.rawBody (String, optional): Sets the raw body for an HTTP request. If this is used, then the contentproperty is ignored. This is mostly useful for HTTP methods that havea body to their requests, like PUT or POST. This property can be used insteadof postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.ioPublish (Boolean, optional): Set this explicitly to false to prevent publishing of topics related toIO operations. Otherwise, if djConfig.ioPublish is set to true, topicswill be published via dojo/topic.publish() for different phases of an IO operation.See dojo/main.__IoPublish for a list of topics that are published.            
         */
        ioMethod(args: Object): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param params             
         * @param node             
         * @param ctor             
         */
        markupFactory(params: any, node: any, ctor: any): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * 
         */
        postMixInProperties(): void;
        /**
         * [Re]download contents of href and display
         * cancels any currently in-flight requests
         * posts "loading..." message
         * sends XHR to download new data
         * 
         */
        refresh(): any;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * See dijit/layout/_LayoutWidget.resize() for description.
         * Although ContentPane doesn't extend _LayoutWidget, it does implement
         * the same API.
         * 
         * @param changeSize             
         * @param resultSize             
         */
        resize(changeSize: any, resultSize: any): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: String): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: HTMLElement): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: NodeList): void;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: String): any;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: URL): any;
        /**
         * Deprecated.  Use set('title', ...) instead.
         * 
         * @param title             
         */
        setTitle(title: String): void;
        /**
         * Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * 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.
         * 
         * @param error             
         */
        onContentError(error: Error): void;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when download is finished.
         * 
         */
        onDownloadEnd(): 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.
         * 
         * @param error             
         */
        onDownloadError(error: Error): any;
        /**
         * Called before download starts.
         * The string returned by this function will be the html
         * that tells the user we are loading something.
         * Override with your own function if you want to change text.
         * 
         */
        onDownloadStart(): any;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Event hook, is called after everything is loaded and widgetified
         * 
         * @param data             
         */
        onLoad(data: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
        /**
         * Event hook, is called before old content is cleared
         * 
         */
        onUnload(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/DropDownMenu.html
     *
     * A menu, without features for context menu (Meaning, drop down menu)
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class DropDownMenu extends dijit._MenuBase implements dijit._OnDijitClickMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * This Menu has been clicked (mouse or via space/arrow key) or opened as a submenu,
         * so mere mouseover will open submenus.  Focusing a menu via TAB does NOT automatically make it active
         * since TAB is a navigation operation and not a selection one.
         * For Windows apps, pressing the ALT key focuses the menubar menus (similar to TAB navigation) but the
         * menu is not active (ie no dropdown) until an item is clicked.
         * 
         */
        "activated": boolean;
        set(property:"activated", value: boolean): void;
        get(property:"activated"): boolean;
        watch(property:"activated", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A toggle to control whether or not a Menu gets focused when opened as a drop down from a MenuBar
         * or DropDownButton/ComboButton.   Note though that it always get focused when opened via the keyboard.
         * 
         */
        "autoFocus": boolean;
        set(property:"autoFocus", value: boolean): void;
        get(property:"autoFocus"): boolean;
        watch(property:"autoFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The currently focused child widget, or null if there isn't one
         * 
         */
        "focusedChild": Object;
        set(property:"focusedChild", value: Object): void;
        get(property:"focusedChild"): Object;
        watch(property:"focusedChild", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If multiple characters are typed where each keystroke happens within
         * multiCharSearchDuration of the previous keystroke,
         * search for nodes matching all the keystrokes.
         * 
         * For example, typing "ab" will search for entries starting with
         * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
         * 
         */
        "multiCharSearchDuration": number;
        set(property:"multiCharSearchDuration", value: number): void;
        get(property:"multiCharSearchDuration"): number;
        watch(property:"multiCharSearchDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to menu that displayed me
         * 
         */
        "parentMenu": Object;
        set(property:"parentMenu", value: Object): void;
        get(property:"parentMenu"): Object;
        watch(property:"parentMenu", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * For a passive (unclicked) Menu, number of milliseconds before hovering (without clicking) will cause
         * the popup to open.  Default is Infinity, meaning you need to click the menu to open it.
         * 
         */
        "passivePopupDelay": number;
        set(property:"passivePopupDelay", value: number): void;
        get(property:"passivePopupDelay"): number;
        watch(property:"passivePopupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * After a menu has been activated (by clicking on it etc.), number of milliseconds before hovering
         * (without clicking) another MenuItem causes that MenuItem's popup to automatically open.
         * 
         */
        "popupDelay": number;
        set(property:"popupDelay", value: number): void;
        get(property:"popupDelay"): number;
        watch(property:"popupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Currently selected (a.k.a. highlighted) MenuItem, or null if no MenuItem is selected.
         * If a submenu is open, will be set to MenuItem that displayed the submenu.   OTOH, if
         * this Menu is in passive mode (i.e. hasn't been clicked yet), will be null, because
         * "selected" is not merely "hovered".
         * 
         */
        "selected": Object;
        set(property:"selected", value: Object): void;
        get(property:"selected"): Object;
        watch(property:"selected", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Tab index of the container; same as HTML tabIndex attribute.
         * Note then when user tabs into the container, focus is immediately
         * moved to the first item in the container.
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Selector (passed to on.selector()) used to identify MenuItem child widgets, but exclude inert children
         * like MenuSeparator.  If subclass overrides to a string (ex: "> *"), the subclass must require dojo/query.
         * 
         * @param node             
         */
        childSelector(node: HTMLElement): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Deprecated.  You can call this in postCreate() to attach the keyboard handlers to the container,
         * but the preferred method is to override _onLeftArrow() and _onRightArrow(), or
         * _onUpArrow() and _onDownArrow(), to call focusPrev() and focusNext().
         * 
         * @param prevKeyCodes Key codes for navigating to the previous child.             
         * @param nextKeyCodes Key codes for navigating to the next child.             
         */
        connectKeyNavHandlers(prevKeyCodes: dojo.keys, nextKeyCodes: dojo.keys): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Default focus() implementation: focus the first child.
         * 
         */
        focus(): void;
        /**
         * Focus specified child widget.
         * 
         * @param widget Reference to container's child widget             
         * @param last If true and if widget has multiple focusable nodes, focus thelast one instead of the first one             
         */
        focusChild(widget: dijit._WidgetBase, last: boolean): void;
        /**
         * Focus the first focusable child in the container.
         * 
         */
        focusFirstChild(): void;
        /**
         * Focus the last focusable child in the container.
         * 
         */
        focusLastChild(): void;
        /**
         * Focus the next widget
         * 
         */
        focusNext(): void;
        /**
         * Focus the last focusable node in the previous widget
         * (ex: go to the ComboButton icon section rather than button section)
         * 
         */
        focusPrev(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * 
         */
        startupKeyNavChildren(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Attach point for notification about when the user cancels the current menu
         * This is an internal mechanism used for Menus to signal to their parent to
         * close them.  In general developers should not attach to or override this method.
         * 
         * @param closeAll             
         */
        onCancel(closeAll: boolean): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Attach point for notification about when a menu item has been executed.
         * This is an internal mechanism used for Menus to signal to their parent to
         * close them, because they are about to execute the onClick handler.  In
         * general developers should not attach to or override this method.
         * 
         */
        onExecute(): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Called when cursor is over a MenuItem.
         * 
         * @param item             
         */
        onItemHover(item: dijit.MenuItem): void;
        /**
         * Callback fires when mouse exits a MenuItem
         * 
         * @param item             
         */
        onItemUnhover(item: dijit.MenuItem): void;
        /**
         * Attach point for notification about when a menu item has been searched for
         * via the keyboard search mechanism.
         * 
         * @param item             
         * @param evt             
         * @param searchString             
         * @param numMatches             
         */
        onKeyboardSearch(item: dijit.MenuItem, evt: Event, searchString: String, numMatches: number): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Editor.html
     *
     * A rich text Editing widget
     * This widget provides basic WYSIWYG editing features, based on the browser's
     * underlying rich text editing capability, accompanied by a toolbar (dijit.Toolbar).
     * A plugin model is available to extend the editor's capabilities as well as the
     * the options available in the toolbar.  Content generation may vary across
     * browsers, and clipboard operations may have different results, to name
     * a few limitations.  Note: this widget should not be used with the HTML
     * <TEXTAREA> tag -- see dijit/_editor/RichText for details.
     * 
     * @param params Initial settings for any of the attributes, except readonly attributes.     
     * @param srcNodeRef The editor replaces the specified DOMNode.     
     */
    class Editor extends dijit._editor.RichText {
        constructor(params: Object, srcNodeRef: HTMLElement);
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Events which should be connected to the underlying editing
         * area, events in this array will be addListener with
         * capture=true.
         * 
         */
        "captureEvents": Object;
        set(property:"captureEvents", value: Object): void;
        get(property:"captureEvents"): Object;
        watch(property:"captureEvents", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Whether we shall use custom undo/redo support instead of the native
         * browser support. By default, we now use custom undo.  It works better
         * than native browser support and provides a consistent behavior across
         * browsers with a minimal performance hit.  We already had the hit on
         * the slowest browser, IE, anyway.
         * 
         */
        "customUndo": boolean;
        set(property:"customUndo", value: boolean): void;
        get(property:"customUndo"): boolean;
        watch(property:"customUndo", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The editor is disabled; the text cannot be changed.
         * 
         */
        "disabled": boolean;
        set(property:"disabled", value: boolean): void;
        get(property:"disabled"): boolean;
        watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * When true, disables the browser's native spell checking, if supported.
         * Works only in Firefox.
         * 
         */
        "disableSpellCheck": boolean;
        set(property:"disableSpellCheck", value: boolean): void;
        get(property:"disableSpellCheck"): boolean;
        watch(property:"disableSpellCheck", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * When using customUndo, not every keystroke will be saved as a step.
         * Instead typing (including delete) will be grouped together: after
         * a user stops typing for editActionInterval seconds, a step will be
         * saved; if a user resume typing within editActionInterval seconds,
         * the timeout will be restarted. By default, editActionInterval is 3
         * seconds.
         * 
         */
        "editActionInterval": number;
        set(property:"editActionInterval", value: number): void;
        get(property:"editActionInterval"): number;
        watch(property:"editActionInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * A list of extra plugin names which will be appended to plugins array
         * 
         */
        "extraPlugins": Object;
        set(property:"extraPlugins", value: Object): void;
        get(property:"extraPlugins"): Object;
        watch(property:"extraPlugins", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Focus into this widget when the page is loaded
         * 
         */
        "focusOnLoad": boolean;
        set(property:"focusOnLoad", value: boolean): void;
        get(property:"focusOnLoad"): boolean;
        watch(property:"focusOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Set height to fix the editor at a specific height, with scrolling.
         * By default, this is 300px.  If you want to have the editor always
         * resizes to accommodate the content, use AlwaysShowToolbar plugin
         * and set height="".  If this editor is used within a layout widget,
         * set height="100%".
         * 
         */
        "height": string;
        set(property:"height", value: string): void;
        get(property:"height"): string;
        watch(property:"height", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * whether to inherit the parent's width or simply use 100%
         * 
         */
        "inheritWidth": boolean;
        set(property:"inheritWidth", value: boolean): void;
        get(property:"inheritWidth"): boolean;
        watch(property:"inheritWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "isClosed": boolean;
        set(property:"isClosed", value: boolean): void;
        get(property:"isClosed"): boolean;
        watch(property:"isClosed", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "isLoaded": boolean;
        set(property:"isLoaded", value: boolean): void;
        get(property:"isLoaded"): boolean;
        watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Make tab key and shift-tab indent and outdent rather than navigating.
         * Caution: sing this makes web pages inaccessible to users unable to use a mouse.
         * 
         */
        "isTabIndent": boolean;
        set(property:"isTabIndent", value: boolean): void;
        get(property:"isTabIndent"): boolean;
        watch(property:"isTabIndent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The minimum height that the editor should have.
         * 
         */
        "minHeight": string;
        set(property:"minHeight", value: string): void;
        get(property:"minHeight"): string;
        watch(property:"minHeight", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Specifies the name of a (hidden) <textarea> node on the page that's used to save
         * the editor content on page leave.   Used to restore editor contents after navigating
         * to a new page and then hitting the back button.
         * 
         */
        "name": Object;
        set(property:"name", value: Object): void;
        get(property:"name"): Object;
        watch(property:"name", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deferred which is fired when the editor finishes loading.
         * Call myEditor.onLoadDeferred.then(callback) it to be informed
         * when the rich-text area initialization is finalized.
         * 
         */
        "onLoadDeferred": Object;
        set(property:"onLoadDeferred", value: Object): void;
        get(property:"onLoadDeferred"): Object;
        watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A list of plugin names (as strings) or instances (as objects)
         * for this widget.
         * 
         * When declared in markup, it might look like:
         * 
         * plugins="['bold',{name:'dijit._editor.plugins.FontChoice', command:'fontName', generic:true}]"
         * 
         */
        "plugins": Object;
        set(property:"plugins", value: Object): void;
        get(property:"plugins"): Object;
        watch(property:"plugins", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * semicolon (";") separated list of css files for the editing area
         * 
         */
        "styleSheets": string;
        set(property:"styleSheets", value: string): void;
        get(property:"styleSheets"): string;
        watch(property:"styleSheets", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "updateInterval": number;
        set(property:"updateInterval", value: number): void;
        get(property:"updateInterval"): number;
        watch(property:"updateInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * Add a handler for a keyboard shortcut
         * 
         * @param key             
         * @param ctrl             
         * @param shift             
         * @param handler             
         */
        addKeyHandler(key: String, ctrl: boolean, shift: boolean, handler: Function): void;
        /**
         * Add a handler for a keyboard shortcut
         * 
         * @param key             
         * @param ctrl             
         * @param shift             
         * @param handler             
         */
        addKeyHandler(key: number, ctrl: boolean, shift: boolean, handler: Function): void;
        /**
         * takes a plugin name as a string or a plugin instance and
         * adds it to the toolbar and associates it with this editor
         * instance. The resulting plugin is added to the Editor's
         * plugins array. If index is passed, it's placed in the plugins
         * array at that index. No big magic, but a nice helper for
         * passing in plugin names via markup.
         * 
         * @param plugin String, args object, plugin instance, or plugin constructor             
         * @param index               OptionalUsed when creating an instance fromsomething already in this.plugins. Ensures that the newinstance is assigned to this.plugins at that index.             
         */
        addPlugin(plugin: String, index: number): void;
        /**
         * takes a plugin name as a string or a plugin instance and
         * adds it to the toolbar and associates it with this editor
         * instance. The resulting plugin is added to the Editor's
         * plugins array. If index is passed, it's placed in the plugins
         * array at that index. No big magic, but a nice helper for
         * passing in plugin names via markup.
         * 
         * @param plugin String, args object, plugin instance, or plugin constructor             
         * @param index               OptionalUsed when creating an instance fromsomething already in this.plugins. Ensures that the newinstance is assigned to this.plugins at that index.             
         */
        addPlugin(plugin: Object, index: number): void;
        /**
         * takes a plugin name as a string or a plugin instance and
         * adds it to the toolbar and associates it with this editor
         * instance. The resulting plugin is added to the Editor's
         * plugins array. If index is passed, it's placed in the plugins
         * array at that index. No big magic, but a nice helper for
         * passing in plugin names via markup.
         * 
         * @param plugin String, args object, plugin instance, or plugin constructor             
         * @param index               OptionalUsed when creating an instance fromsomething already in this.plugins. Ensures that the newinstance is assigned to this.plugins at that index.             
         */
        addPlugin(plugin: Function, index: number): void;
        /**
         * add an external stylesheet for the editing area
         * 
         * @param uri Url of the external css file             
         */
        addStyleSheet(uri: dojo._base.url): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Remove focus from this instance.
         * 
         */
        blur(): void;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Main handler for executing any commands to the editor, like paste, bold, etc.
         * Called by plugins, but not meant to be called by end users.
         * 
         * @param cmd             
         */
        execCommand(cmd: any): any;
        /**
         * Move focus to this editor
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * A function for obtaining the height of the footer node
         * 
         */
        getFooterHeight(): any;
        /**
         * A function for obtaining the height of the header node
         * 
         */
        getHeaderHeight(): any;
        /**
         * Deprecated.   Use dijit/_editor/html::getChildrenHtml() instead.
         * 
         * @param dom             
         */
        getNodeChildrenHtml(dom: HTMLElement): any;
        /**
         * Deprecated.   Use dijit/_editor/html::_getNodeHtml() instead.
         * 
         * @param node             
         */
        getNodeHtml(node: HTMLElement): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * Called from dijit/layout/_LayoutWidget.resize().  This shouldn't be called directly
         * 
         */
        layout(): void;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Extension to make sure a deferred is in place before certain functions
         * execute, like making sure all the plugins are properly inserted.
         * 
         */
        postMixInProperties(): void;
        /**
         * Returns true if specified editor command is enabled.
         * Used by the plugins to know when to highlight/not highlight buttons.
         * 
         * @param cmd             
         */
        queryCommandEnabled(cmd: any): any;
        /**
         * Check the state of a given command and returns true or false.
         * 
         * @param command             
         */
        queryCommandState(command: any): any;
        /**
         * Check the value of a given command. This matters most for
         * custom selections and complex values like font value setting.
         * 
         * @param command             
         */
        queryCommandValue(command: any): any;
        /**
         * remove an external stylesheet for the editing area
         * 
         * @param uri             
         */
        removeStyleSheet(uri: dojo._base.url): void;
        /**
         * over-ride of replaceValue to support custom undo and stack maintenance.
         * 
         * @param html             
         */
        replaceValue(html: String): void;
        /**
         * Resize the editor to the specified size, see dijit/layout/_LayoutWidget.resize()
         * 
         * @param size             
         */
        resize(size: any): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated, use set('disabled', ...) instead.
         * 
         * @param disabled             
         */
        setDisabled(disabled: boolean): void;
        /**
         * Add some default key handlers
         * Overwrite this to setup your own handlers. The default
         * implementation does not use Editor commands, but directly
         * executes the builtin commands within the underlying browser
         * support.
         * 
         */
        setupDefaultShortcuts(): void;
        /**
         * This function sets the content. No undo history is preserved.
         * Users should use set('value', ...) instead.
         * 
         * @param html             
         */
        setValue(html: String): void;
        /**
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * 
         */
        onBeforeActivate(): void;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * This is fired if and only if the editor loses focus and
         * the content is changed.
         * 
         * @param newContent             
         */
        onChange(newContent: any): void;
        /**
         * Handler for when editor is clicked
         * 
         */
        onClick(): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Handler for onkeyup event
         * 
         * @param e             
         */
        onKeyUp(e: any): void;
        /**
         * Handler after the iframe finishes loading.
         * 
         * @param html Editor contents should be set to this value             
         */
        onLoad(html: String): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/InlineEditBox.html
     *
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my valuereplace srcNodeRef with my generated DOM tree     
     */
    class InlineEditBox extends dijit._Widget {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Changing the value automatically saves it; don't have to push save button
         * (and save button isn't even displayed)
         * 
         */
        "autoSave": boolean;
        set(property:"autoSave", value: boolean): void;
        get(property:"autoSave"): boolean;
        watch(property:"autoSave", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Cancel button label
         * 
         */
        "buttonCancel": string;
        set(property:"buttonCancel", value: string): void;
        get(property:"buttonCancel"): string;
        watch(property:"buttonCancel", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Save button label
         * 
         */
        "buttonSave": string;
        set(property:"buttonSave", value: string): void;
        get(property:"buttonSave"): string;
        watch(property:"buttonSave", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If true, clicking the InlineEditBox to edit it will have no effect.
         * 
         */
        "disabled": boolean;
        set(property:"disabled", value: boolean): void;
        get(property:"disabled"): boolean;
        watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Is the node currently in edit mode?
         * 
         */
        "editing": boolean;
        set(property:"editing", value: boolean): void;
        get(property:"editing"): boolean;
        watch(property:"editing", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Set of parameters for editor, like {required: true}
         * 
         */
        "editorParams": Object;
        set(property:"editorParams", value: Object): void;
        get(property:"editorParams"): Object;
        watch(property:"editorParams", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The text that gets displayed when there is no value (so that the user has a place to click to edit)
         * 
         */
        "noValueIndicator": string;
        set(property:"noValueIndicator", value: string): void;
        get(property:"noValueIndicator"): string;
        watch(property:"noValueIndicator", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Set this to true if the specified Editor's value should be interpreted as HTML
         * rather than plain text (ex: dijit.Editor)
         * 
         */
        "renderAsHtml": boolean;
        set(property:"renderAsHtml", value: boolean): void;
        get(property:"renderAsHtml"): boolean;
        watch(property:"renderAsHtml", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The display value of the widget in read-only mode
         * 
         */
        "value": string;
        set(property:"value", value: string): void;
        get(property:"value"): string;
        watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Width of editor.  By default it's width=100% (ie, block mode).
         * 
         */
        "width": string;
        set(property:"width", value: string): void;
        get(property:"width"): string;
        watch(property:"width", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * MID (ex: "dijit/form/TextBox") or constructor for editor widget
         * 
         */
        editor(): void;
        /**
         * Class name (or reference to the Class) for widget that wraps the editor widget, displaying save/cancel
         * buttons.
         * 
         */
        editorWrapper(): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Deprecated.   Use get('value') instead.
         * 
         */
        getValue(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('disabled', ...) instead.
         * 
         * @param disabled             
         */
        setDisabled(disabled: boolean): void;
        /**
         * Deprecated.   Use set('value', ...) instead.
         * 
         * @param val             
         */
        setValue(val: String): any;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Set this handler to be notified when editing is cancelled.
         * 
         */
        onCancel(): void;
        /**
         * Set this handler to be notified of changes to value.
         * 
         * @param value             
         */
        onChange(value: any): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    module InlineEditBox {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/InlineEditBox._InlineEditor.html
         *
         * Internal widget used by InlineEditBox, displayed when in editing mode
         * to display the editor and maybe save/cancel buttons.  Calling code should
         * connect to save/cancel methods to detect when editing is finished
         * 
         * Has mainly the same parameters as InlineEditBox, plus these values:
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _InlineEditor extends dijit._Widget implements dijit._TemplatedMixin, dijit._WidgetsInTemplateMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Set of CSS attributes of display node, to replicate in editor
             * 
             */
            "style": Object;
            set(property:"style", value: Object): void;
            get(property:"style"): Object;
            watch(property:"style", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Value as an HTML string or plain text string, depending on renderAsHTML flag
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should we parse the template to find widgets that might be
             * declared in markup inside it?  (Remove for 2.0 and assume true)
             * 
             */
            "widgetsInTemplate": boolean;
            set(property:"widgetsInTemplate", value: boolean): void;
            get(property:"widgetsInTemplate"): boolean;
            watch(property:"widgetsInTemplate", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * 
             */
            contextRequire(): void;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * User overridable function returning a Boolean to indicate
             * if the Save button should be enabled or not - usually due to invalid conditions
             * 
             */
            enableSave(): boolean;
            /**
             * Focus the edit widget.
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return the [display] value of the edit widget
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/MenuSeparator.html
     *
     * A line between two menu items
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class MenuSeparator extends dijit._WidgetBase implements dijit._TemplatedMixin, dijit._Contained {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns the index of this widget within its container parent.
         * It returns -1 if the parent does not exist, or if the parent
         * is not a dijit/_Container
         * 
         */
        getIndexInParent(): any;
        /**
         * Returns null if this is the last child of the parent,
         * otherwise returns the next element sibling to the "right".
         * 
         */
        getNextSibling(): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns null if this is the first child of the parent,
         * otherwise returns the next element sibling to the "left".
         * 
         */
        getPreviousSibling(): any;
        /**
         * Override to always return false
         * 
         */
        isFocusable(): boolean;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
         * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
         * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
         * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
         * 
         * @param type Name of event (ex: "click") or extension event like touch.press.             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * Processing after the DOM fragment is created
         * Called after the DOM fragment has been created, but not necessarily
         * added to the document.  Do not include any operations which rely on
         * node dimensions or placement.
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/MenuBar.html
     *
     * A menu bar, listing menu choices horizontally, like the "File" menu in most desktop applications
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class MenuBar extends dijit._MenuBase {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * This Menu has been clicked (mouse or via space/arrow key) or opened as a submenu,
         * so mere mouseover will open submenus.  Focusing a menu via TAB does NOT automatically make it active
         * since TAB is a navigation operation and not a selection one.
         * For Windows apps, pressing the ALT key focuses the menubar menus (similar to TAB navigation) but the
         * menu is not active (ie no dropdown) until an item is clicked.
         * 
         */
        "activated": boolean;
        set(property:"activated", value: boolean): void;
        get(property:"activated"): boolean;
        watch(property:"activated", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A toggle to control whether or not a Menu gets focused when opened as a drop down from a MenuBar
         * or DropDownButton/ComboButton.   Note though that it always get focused when opened via the keyboard.
         * 
         */
        "autoFocus": boolean;
        set(property:"autoFocus", value: boolean): void;
        get(property:"autoFocus"): boolean;
        watch(property:"autoFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The currently focused child widget, or null if there isn't one
         * 
         */
        "focusedChild": Object;
        set(property:"focusedChild", value: Object): void;
        get(property:"focusedChild"): Object;
        watch(property:"focusedChild", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If multiple characters are typed where each keystroke happens within
         * multiCharSearchDuration of the previous keystroke,
         * search for nodes matching all the keystrokes.
         * 
         * For example, typing "ab" will search for entries starting with
         * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
         * 
         */
        "multiCharSearchDuration": number;
        set(property:"multiCharSearchDuration", value: number): void;
        get(property:"multiCharSearchDuration"): number;
        watch(property:"multiCharSearchDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to menu that displayed me
         * 
         */
        "parentMenu": Object;
        set(property:"parentMenu", value: Object): void;
        get(property:"parentMenu"): Object;
        watch(property:"parentMenu", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * For a passive (unclicked) Menu, number of milliseconds before hovering (without clicking) will cause
         * the popup to open.  Default is Infinity, meaning you need to click the menu to open it.
         * 
         */
        "passivePopupDelay": number;
        set(property:"passivePopupDelay", value: number): void;
        get(property:"passivePopupDelay"): number;
        watch(property:"passivePopupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * 
         */
        "popupDelay": number;
        set(property:"popupDelay", value: number): void;
        get(property:"popupDelay"): number;
        watch(property:"popupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Currently selected (a.k.a. highlighted) MenuItem, or null if no MenuItem is selected.
         * If a submenu is open, will be set to MenuItem that displayed the submenu.   OTOH, if
         * this Menu is in passive mode (i.e. hasn't been clicked yet), will be null, because
         * "selected" is not merely "hovered".
         * 
         */
        "selected": Object;
        set(property:"selected", value: Object): void;
        get(property:"selected"): Object;
        watch(property:"selected", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Tab index of the container; same as HTML tabIndex attribute.
         * Note then when user tabs into the container, focus is immediately
         * moved to the first item in the container.
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Selector (passed to on.selector()) used to identify MenuItem child widgets, but exclude inert children
         * like MenuSeparator.  If subclass overrides to a string (ex: "> *"), the subclass must require dojo/query.
         * 
         * @param node             
         */
        childSelector(node: HTMLElement): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Deprecated.  You can call this in postCreate() to attach the keyboard handlers to the container,
         * but the preferred method is to override _onLeftArrow() and _onRightArrow(), or
         * _onUpArrow() and _onDownArrow(), to call focusPrev() and focusNext().
         * 
         * @param prevKeyCodes Key codes for navigating to the previous child.             
         * @param nextKeyCodes Key codes for navigating to the next child.             
         */
        connectKeyNavHandlers(prevKeyCodes: dojo.keys, nextKeyCodes: dojo.keys): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Default focus() implementation: focus the first child.
         * 
         */
        focus(): void;
        /**
         * 
         * @param item             
         */
        focusChild(item: any): void;
        /**
         * Focus the first focusable child in the container.
         * 
         */
        focusFirstChild(): void;
        /**
         * Focus the last focusable child in the container.
         * 
         */
        focusLastChild(): void;
        /**
         * Focus the next widget
         * 
         */
        focusNext(): void;
        /**
         * Focus the last focusable node in the previous widget
         * (ex: go to the ComboButton icon section rather than button section)
         * 
         */
        focusPrev(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * 
         */
        startupKeyNavChildren(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Attach point for notification about when the user cancels the current menu
         * This is an internal mechanism used for Menus to signal to their parent to
         * close them.  In general developers should not attach to or override this method.
         * 
         * @param closeAll             
         */
        onCancel(closeAll: boolean): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Attach point for notification about when a menu item has been executed.
         * This is an internal mechanism used for Menus to signal to their parent to
         * close them, because they are about to execute the onClick handler.  In
         * general developers should not attach to or override this method.
         * 
         */
        onExecute(): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Called when cursor is over a MenuItem.
         * 
         * @param item             
         */
        onItemHover(item: dijit.MenuItem): void;
        /**
         * Callback fires when mouse exits a MenuItem
         * 
         * @param item             
         */
        onItemUnhover(item: dijit.MenuItem): void;
        /**
         * Attach point for notification about when a menu item has been searched for
         * via the keyboard search mechanism.
         * 
         * @param item             
         * @param evt             
         * @param searchString             
         * @param numMatches             
         */
        onKeyboardSearch(item: dijit.MenuItem, evt: Event, searchString: String, numMatches: number): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Menu.html
     *
     * A context menu you can assign to multiple elements
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsreplace srcNodeRef with my generated DOM tree     
     */
    class Menu extends dijit.DropDownMenu {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * This Menu has been clicked (mouse or via space/arrow key) or opened as a submenu,
         * so mere mouseover will open submenus.  Focusing a menu via TAB does NOT automatically make it active
         * since TAB is a navigation operation and not a selection one.
         * For Windows apps, pressing the ALT key focuses the menubar menus (similar to TAB navigation) but the
         * menu is not active (ie no dropdown) until an item is clicked.
         * 
         */
        "activated": boolean;
        set(property:"activated", value: boolean): void;
        get(property:"activated"): boolean;
        watch(property:"activated", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A toggle to control whether or not a Menu gets focused when opened as a drop down from a MenuBar
         * or DropDownButton/ComboButton.   Note though that it always get focused when opened via the keyboard.
         * 
         */
        "autoFocus": boolean;
        set(property:"autoFocus", value: boolean): void;
        get(property:"autoFocus"): boolean;
        watch(property:"autoFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * If true, right clicking anywhere on the window will cause this context menu to open.
         * If false, must specify targetNodeIds.
         * 
         */
        "contextMenuForWindow": boolean;
        set(property:"contextMenuForWindow", value: boolean): void;
        get(property:"contextMenuForWindow"): boolean;
        watch(property:"contextMenuForWindow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * For context menus, set to the current node that the Menu is being displayed for.
         * Useful so that the menu actions can be tailored according to the node
         * 
         */
        "currentTarget": HTMLElement;
        set(property:"currentTarget", value: HTMLElement): void;
        get(property:"currentTarget"): HTMLElement;
        watch(property:"currentTarget", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The currently focused child widget, or null if there isn't one
         * 
         */
        "focusedChild": Object;
        set(property:"focusedChild", value: Object): void;
        get(property:"focusedChild"): Object;
        watch(property:"focusedChild", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If true, menu will open on left click instead of right click, similar to a file menu.
         * 
         */
        "leftClickToOpen": boolean;
        set(property:"leftClickToOpen", value: boolean): void;
        get(property:"leftClickToOpen"): boolean;
        watch(property:"leftClickToOpen", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * If multiple characters are typed where each keystroke happens within
         * multiCharSearchDuration of the previous keystroke,
         * search for nodes matching all the keystrokes.
         * 
         * For example, typing "ab" will search for entries starting with
         * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
         * 
         */
        "multiCharSearchDuration": number;
        set(property:"multiCharSearchDuration", value: number): void;
        get(property:"multiCharSearchDuration"): number;
        watch(property:"multiCharSearchDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to menu that displayed me
         * 
         */
        "parentMenu": Object;
        set(property:"parentMenu", value: Object): void;
        get(property:"parentMenu"): Object;
        watch(property:"parentMenu", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * For a passive (unclicked) Menu, number of milliseconds before hovering (without clicking) will cause
         * the popup to open.  Default is Infinity, meaning you need to click the menu to open it.
         * 
         */
        "passivePopupDelay": number;
        set(property:"passivePopupDelay", value: number): void;
        get(property:"passivePopupDelay"): number;
        watch(property:"passivePopupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * After a menu has been activated (by clicking on it etc.), number of milliseconds before hovering
         * (without clicking) another MenuItem causes that MenuItem's popup to automatically open.
         * 
         */
        "popupDelay": number;
        set(property:"popupDelay", value: number): void;
        get(property:"popupDelay"): number;
        watch(property:"popupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * When this menu closes, re-focus the element which had focus before it was opened.
         * 
         */
        "refocus": boolean;
        set(property:"refocus", value: boolean): void;
        get(property:"refocus"): boolean;
        watch(property:"refocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Currently selected (a.k.a. highlighted) MenuItem, or null if no MenuItem is selected.
         * If a submenu is open, will be set to MenuItem that displayed the submenu.   OTOH, if
         * this Menu is in passive mode (i.e. hasn't been clicked yet), will be null, because
         * "selected" is not merely "hovered".
         * 
         */
        "selected": Object;
        set(property:"selected", value: Object): void;
        get(property:"selected"): Object;
        watch(property:"selected", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * CSS expression to apply this Menu to descendants of targetNodeIds, rather than to
         * the nodes specified by targetNodeIds themselves.  Useful for applying a Menu to
         * a range of rows in a table, tree, etc.
         * 
         * The application must require() an appropriate level of dojo/query to handle the selector.
         * 
         */
        "selector": Object;
        set(property:"selector", value: Object): void;
        get(property:"selector"): Object;
        watch(property:"selector", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Tab index of the container; same as HTML tabIndex attribute.
         * Note then when user tabs into the container, focus is immediately
         * moved to the first item in the container.
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Array of dom node ids of nodes to attach to.
         * Fill this with nodeIds upon widget creation and it becomes context menu for those nodes.
         * 
         */
        "targetNodeIds": Object;
        set(property:"targetNodeIds", value: Object): void;
        get(property:"targetNodeIds"): Object;
        watch(property:"targetNodeIds", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Attach menu to given node
         * 
         * @param node             
         */
        bindDomNode(node: String): void;
        /**
         * Attach menu to given node
         * 
         * @param node             
         */
        bindDomNode(node: HTMLElement): void;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Selector (passed to on.selector()) used to identify MenuItem child widgets, but exclude inert children
         * like MenuSeparator.  If subclass overrides to a string (ex: "> *"), the subclass must require dojo/query.
         * 
         * @param node             
         */
        childSelector(node: HTMLElement): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Deprecated.  You can call this in postCreate() to attach the keyboard handlers to the container,
         * but the preferred method is to override _onLeftArrow() and _onRightArrow(), or
         * _onUpArrow() and _onDownArrow(), to call focusPrev() and focusNext().
         * 
         * @param prevKeyCodes Key codes for navigating to the previous child.             
         * @param nextKeyCodes Key codes for navigating to the next child.             
         */
        connectKeyNavHandlers(prevKeyCodes: dojo.keys, nextKeyCodes: dojo.keys): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Default focus() implementation: focus the first child.
         * 
         */
        focus(): void;
        /**
         * Focus specified child widget.
         * 
         * @param widget Reference to container's child widget             
         * @param last If true and if widget has multiple focusable nodes, focus thelast one instead of the first one             
         */
        focusChild(widget: dijit._WidgetBase, last: boolean): void;
        /**
         * Focus the first focusable child in the container.
         * 
         */
        focusFirstChild(): void;
        /**
         * Focus the last focusable child in the container.
         * 
         */
        focusLastChild(): void;
        /**
         * Focus the next widget
         * 
         */
        focusNext(): void;
        /**
         * Focus the last focusable node in the previous widget
         * (ex: go to the ComboButton icon section rather than button section)
         * 
         */
        focusPrev(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns an array of placeholders with the given label.  There
         * can be multiples.
         * 
         * @param label               OptionalLabel to search for - if not specified, then all placeholdersare returned             
         */
        getPlaceholders(label: String): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * 
         */
        startupKeyNavChildren(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Detach menu from given node
         * 
         * @param nodeName             
         */
        unBindDomNode(nodeName: String): void;
        /**
         * Detach menu from given node
         * 
         * @param nodeName             
         */
        unBindDomNode(nodeName: HTMLElement): void;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Attach point for notification about when the user cancels the current menu
         * This is an internal mechanism used for Menus to signal to their parent to
         * close them.  In general developers should not attach to or override this method.
         * 
         * @param closeAll             
         */
        onCancel(closeAll: boolean): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Attach point for notification about when a menu item has been executed.
         * This is an internal mechanism used for Menus to signal to their parent to
         * close them, because they are about to execute the onClick handler.  In
         * general developers should not attach to or override this method.
         * 
         */
        onExecute(): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Called when cursor is over a MenuItem.
         * 
         * @param item             
         */
        onItemHover(item: dijit.MenuItem): void;
        /**
         * Callback fires when mouse exits a MenuItem
         * 
         * @param item             
         */
        onItemUnhover(item: dijit.MenuItem): void;
        /**
         * Attach point for notification about when a menu item has been searched for
         * via the keyboard search mechanism.
         * 
         * @param item             
         * @param evt             
         * @param searchString             
         * @param numMatches             
         */
        onKeyboardSearch(item: dijit.MenuItem, evt: Event, searchString: String, numMatches: number): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/MenuItem.html
     *
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class MenuItem extends dijit._Widget implements dijit._TemplatedMixin, dijit._Contained, dijit._CssStateMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Text for the accelerator (shortcut) key combination, a control, alt, etc. modified keystroke meant to
         * execute the menu item regardless of where the focus is on the page.
         * 
         * Note that although Menu can display accelerator keys, there is no infrastructure to actually catch and
         * execute those accelerators.
         * 
         */
        "accelKey": string;
        set(property:"accelKey", value: string): void;
        get(property:"accelKey"): string;
        watch(property:"accelKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If true, the menu item is disabled.
         * If false, the menu item is enabled.
         * 
         */
        "disabled": boolean;
        set(property:"disabled", value: boolean): void;
        get(property:"disabled"): boolean;
        watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Class to apply to DOMNode to make it display an icon.
         * 
         */
        "iconClass": string;
        set(property:"iconClass", value: string): void;
        get(property:"iconClass"): string;
        watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Menu text as HTML
         * 
         */
        "label": string;
        set(property:"label", value: string): void;
        get(property:"label"): string;
        watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Single character (underlined when the parent Menu is focused) used to navigate directly to this widget,
         * also known as a mnemonic.
         * This is denoted in the label by surrounding the single character with {}.
         * For example, if label="{F}ile", then shortcutKey="F".
         * 
         */
        "shortcutKey": string;
        set(property:"shortcutKey", value: string): void;
        get(property:"shortcutKey"): string;
        watch(property:"shortcutKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Focus on this MenuItem
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the index of this widget within its container parent.
         * It returns -1 if the parent does not exist, or if the parent
         * is not a dijit/_Container
         * 
         */
        getIndexInParent(): any;
        /**
         * Returns null if this is the last child of the parent,
         * otherwise returns the next element sibling to the "right".
         * 
         */
        getNextSibling(): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns null if this is the first child of the parent,
         * otherwise returns the next element sibling to the "left".
         * 
         */
        getPreviousSibling(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('disabled', bool) instead.
         * 
         * @param disabled             
         */
        setDisabled(disabled: boolean): void;
        /**
         * Deprecated.   Use set('label', ...) instead.
         * 
         * @param content             
         */
        setLabel(content: String): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * User defined function to handle clicks
         * 
         */
        onClick(): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/MenuBarItem.html
     *
     * Item in a MenuBar that's clickable, and doesn't spawn a submenu when pressed (or hovered)
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class MenuBarItem extends dijit.MenuItem {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Text for the accelerator (shortcut) key combination, a control, alt, etc. modified keystroke meant to
         * execute the menu item regardless of where the focus is on the page.
         * 
         * Note that although Menu can display accelerator keys, there is no infrastructure to actually catch and
         * execute those accelerators.
         * 
         */
        "accelKey": string;
        set(property:"accelKey", value: string): void;
        get(property:"accelKey"): string;
        watch(property:"accelKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If true, the menu item is disabled.
         * If false, the menu item is enabled.
         * 
         */
        "disabled": boolean;
        set(property:"disabled", value: boolean): void;
        get(property:"disabled"): boolean;
        watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Class to apply to DOMNode to make it display an icon.
         * 
         */
        "iconClass": string;
        set(property:"iconClass", value: string): void;
        get(property:"iconClass"): string;
        watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Menu text as HTML
         * 
         */
        "label": string;
        set(property:"label", value: string): void;
        get(property:"label"): string;
        watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Single character (underlined when the parent Menu is focused) used to navigate directly to this widget,
         * also known as a mnemonic.
         * This is denoted in the label by surrounding the single character with {}.
         * For example, if label="{F}ile", then shortcutKey="F".
         * 
         */
        "shortcutKey": string;
        set(property:"shortcutKey", value: string): void;
        get(property:"shortcutKey"): string;
        watch(property:"shortcutKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Focus on this MenuItem
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the index of this widget within its container parent.
         * It returns -1 if the parent does not exist, or if the parent
         * is not a dijit/_Container
         * 
         */
        getIndexInParent(): any;
        /**
         * Returns null if this is the last child of the parent,
         * otherwise returns the next element sibling to the "right".
         * 
         */
        getNextSibling(): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns null if this is the first child of the parent,
         * otherwise returns the next element sibling to the "left".
         * 
         */
        getPreviousSibling(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('disabled', bool) instead.
         * 
         * @param disabled             
         */
        setDisabled(disabled: boolean): void;
        /**
         * Deprecated.   Use set('label', ...) instead.
         * 
         * @param content             
         */
        setLabel(content: String): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * User defined function to handle clicks
         * 
         */
        onClick(): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    module MenuBarItem {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/MenuBarItem._MenuBarItemMixin.html
         *
         * 
         */
        class _MenuBarItemMixin {
            constructor();
            /**
             * 
             */
            "templateString": string;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/PopupMenuBarItem.html
     *
     * Item in a MenuBar like "File" or "Edit", that spawns a submenu when pressed (or hovered)
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class PopupMenuBarItem extends dijit.PopupMenuItem {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Text for the accelerator (shortcut) key combination, a control, alt, etc. modified keystroke meant to
         * execute the menu item regardless of where the focus is on the page.
         * 
         * Note that although Menu can display accelerator keys, there is no infrastructure to actually catch and
         * execute those accelerators.
         * 
         */
        "accelKey": string;
        set(property:"accelKey", value: string): void;
        get(property:"accelKey"): string;
        watch(property:"accelKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If true, the menu item is disabled.
         * If false, the menu item is enabled.
         * 
         */
        "disabled": boolean;
        set(property:"disabled", value: boolean): void;
        get(property:"disabled"): boolean;
        watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Class to apply to DOMNode to make it display an icon.
         * 
         */
        "iconClass": string;
        set(property:"iconClass", value: string): void;
        get(property:"iconClass"): string;
        watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Menu text as HTML
         * 
         */
        "label": string;
        set(property:"label", value: string): void;
        get(property:"label"): string;
        watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Single character (underlined when the parent Menu is focused) used to navigate directly to this widget,
         * also known as a mnemonic.
         * This is denoted in the label by surrounding the single character with {}.
         * For example, if label="{F}ile", then shortcutKey="F".
         * 
         */
        "shortcutKey": string;
        set(property:"shortcutKey", value: string): void;
        get(property:"shortcutKey"): string;
        watch(property:"shortcutKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * 
         * @param preserveDom             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Focus on this MenuItem
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the index of this widget within its container parent.
         * It returns -1 if the parent does not exist, or if the parent
         * is not a dijit/_Container
         * 
         */
        getIndexInParent(): any;
        /**
         * Returns null if this is the last child of the parent,
         * otherwise returns the next element sibling to the "right".
         * 
         */
        getNextSibling(): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns null if this is the first child of the parent,
         * otherwise returns the next element sibling to the "left".
         * 
         */
        getPreviousSibling(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('disabled', bool) instead.
         * 
         * @param disabled             
         */
        setDisabled(disabled: boolean): void;
        /**
         * Deprecated.   Use set('label', ...) instead.
         * 
         * @param content             
         */
        setLabel(content: String): void;
        /**
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * User defined function to handle clicks
         * 
         */
        onClick(): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/PopupMenuItem.html
     *
     * An item in a Menu that spawn a drop down (usually a drop down menu)
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class PopupMenuItem extends dijit.MenuItem {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Text for the accelerator (shortcut) key combination, a control, alt, etc. modified keystroke meant to
         * execute the menu item regardless of where the focus is on the page.
         * 
         * Note that although Menu can display accelerator keys, there is no infrastructure to actually catch and
         * execute those accelerators.
         * 
         */
        "accelKey": string;
        set(property:"accelKey", value: string): void;
        get(property:"accelKey"): string;
        watch(property:"accelKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If true, the menu item is disabled.
         * If false, the menu item is enabled.
         * 
         */
        "disabled": boolean;
        set(property:"disabled", value: boolean): void;
        get(property:"disabled"): boolean;
        watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Class to apply to DOMNode to make it display an icon.
         * 
         */
        "iconClass": string;
        set(property:"iconClass", value: string): void;
        get(property:"iconClass"): string;
        watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Menu text as HTML
         * 
         */
        "label": string;
        set(property:"label", value: string): void;
        get(property:"label"): string;
        watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Single character (underlined when the parent Menu is focused) used to navigate directly to this widget,
         * also known as a mnemonic.
         * This is denoted in the label by surrounding the single character with {}.
         * For example, if label="{F}ile", then shortcutKey="F".
         * 
         */
        "shortcutKey": string;
        set(property:"shortcutKey", value: string): void;
        get(property:"shortcutKey"): string;
        watch(property:"shortcutKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * 
         * @param preserveDom             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Focus on this MenuItem
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the index of this widget within its container parent.
         * It returns -1 if the parent does not exist, or if the parent
         * is not a dijit/_Container
         * 
         */
        getIndexInParent(): any;
        /**
         * Returns null if this is the last child of the parent,
         * otherwise returns the next element sibling to the "right".
         * 
         */
        getNextSibling(): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns null if this is the first child of the parent,
         * otherwise returns the next element sibling to the "left".
         * 
         */
        getPreviousSibling(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('disabled', bool) instead.
         * 
         * @param disabled             
         */
        setDisabled(disabled: boolean): void;
        /**
         * Deprecated.   Use set('label', ...) instead.
         * 
         * @param content             
         */
        setLabel(content: String): void;
        /**
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * User defined function to handle clicks
         * 
         */
        onClick(): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/ProgressBar.html
     *
     * A progress indication widget, showing the amount completed
     * (often the percentage completed) of a task.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class ProgressBar extends dijit._Widget implements dijit._TemplatedMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If false: show progress value (number or percentage).
         * If true: show that a process is underway but that the amount completed is unknown.
         * Deprecated.   Use "value" instead.
         * 
         */
        "indeterminate": boolean;
        set(property:"indeterminate", value: boolean): void;
        get(property:"indeterminate"): boolean;
        watch(property:"indeterminate", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * HTML label on progress bar.   Defaults to percentage for determinate progress bar and
         * blank for indeterminate progress bar.
         * 
         */
        "label": Object;
        set(property:"label", value: Object): void;
        get(property:"label"): Object;
        watch(property:"label", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Max sample number
         * 
         */
        "maximum": number;
        set(property:"maximum", value: number): void;
        get(property:"maximum"): number;
        watch(property:"maximum", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * this is the field name (for a form) if set. This needs to be set if you want to use
         * this widget in a dijit/form/Form widget (such as dijit/Dialog)
         * 
         */
        "name": string;
        set(property:"name", value: string): void;
        get(property:"name"): string;
        watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Number of places to show in values; 0 by default
         * 
         */
        "places": number;
        set(property:"places", value: number): void;
        get(property:"places"): number;
        watch(property:"places", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * Number or percentage indicating amount of task completed.
         * Deprecated.   Use "value" instead.
         * 
         */
        "progress": string;
        set(property:"progress", value: string): void;
        get(property:"progress"): string;
        watch(property:"progress", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Number or percentage indicating amount of task completed.
         * With "%": percentage value, 0% <= progress <= 100%, or
         * without "%": absolute value, 0 <= progress <= maximum.
         * Infinity means that the progress bar is indeterminate.
         * 
         */
        "value": string;
        set(property:"value", value: string): void;
        get(property:"value"): string;
        watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * 
         */
        postMixInProperties(): void;
        /**
         * Generates HTML message to show inside progress bar (normally indicating amount of task completed).
         * May be overridden.
         * 
         * @param percent             
         */
        report(percent: number): any;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Callback fired when progress updates.
         * 
         */
        onChange(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/RadioMenuItem.html
     *
     * A radio-button-like menu item for toggling on and off
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class RadioMenuItem extends dijit.CheckedMenuItem {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Text for the accelerator (shortcut) key combination, a control, alt, etc. modified keystroke meant to
         * execute the menu item regardless of where the focus is on the page.
         * 
         * Note that although Menu can display accelerator keys, there is no infrastructure to actually catch and
         * execute those accelerators.
         * 
         */
        "accelKey": string;
        set(property:"accelKey", value: string): void;
        get(property:"accelKey"): string;
        watch(property:"accelKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Our checked state
         * 
         */
        "checked": boolean;
        set(property:"checked", value: boolean): void;
        get(property:"checked"): boolean;
        watch(property:"checked", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Character (or string) used in place of radio button icon when display in high contrast mode
         * 
         */
        "checkedChar": string;
        set(property:"checkedChar", value: string): void;
        get(property:"checkedChar"): string;
        watch(property:"checkedChar", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If true, the menu item is disabled.
         * If false, the menu item is enabled.
         * 
         */
        "disabled": boolean;
        set(property:"disabled", value: boolean): void;
        get(property:"disabled"): boolean;
        watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Toggling on a RadioMenuItem in a given group toggles off the other RadioMenuItems in that group.
         * 
         */
        "group": string;
        set(property:"group", value: string): void;
        get(property:"group"): string;
        watch(property:"group", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "iconClass": string;
        set(property:"iconClass", value: string): void;
        get(property:"iconClass"): string;
        watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Menu text as HTML
         * 
         */
        "label": string;
        set(property:"label", value: string): void;
        get(property:"label"): string;
        watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "role": string;
        set(property:"role", value: string): void;
        get(property:"role"): string;
        watch(property:"role", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Single character (underlined when the parent Menu is focused) used to navigate directly to this widget,
         * also known as a mnemonic.
         * This is denoted in the label by surrounding the single character with {}.
         * For example, if label="{F}ile", then shortcutKey="F".
         * 
         */
        "shortcutKey": string;
        set(property:"shortcutKey", value: string): void;
        get(property:"shortcutKey"): string;
        watch(property:"shortcutKey", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Focus on this MenuItem
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the index of this widget within its container parent.
         * It returns -1 if the parent does not exist, or if the parent
         * is not a dijit/_Container
         * 
         */
        getIndexInParent(): any;
        /**
         * Returns null if this is the last child of the parent,
         * otherwise returns the next element sibling to the "right".
         * 
         */
        getNextSibling(): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns null if this is the first child of the parent,
         * otherwise returns the next element sibling to the "left".
         * 
         */
        getPreviousSibling(): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('disabled', bool) instead.
         * 
         * @param disabled             
         */
        setDisabled(disabled: boolean): void;
        /**
         * Deprecated.   Use set('label', ...) instead.
         * 
         * @param content             
         */
        setLabel(content: String): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * User defined function to handle check/uncheck events
         * 
         * @param checked             
         */
        onChange(checked: boolean): void;
        /**
         * User defined function to handle clicks
         * 
         */
        onClick(): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Toolbar.html
     *
     * A Toolbar widget, used to hold things like dijit/Editor buttons
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class Toolbar extends dijit._Widget implements dijit._TemplatedMixin, dijit._KeyNavContainer {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The currently focused child widget, or null if there isn't one
         * 
         */
        "focusedChild": Object;
        set(property:"focusedChild", value: Object): void;
        get(property:"focusedChild"): Object;
        watch(property:"focusedChild", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * If multiple characters are typed where each keystroke happens within
         * multiCharSearchDuration of the previous keystroke,
         * search for nodes matching all the keystrokes.
         * 
         * For example, typing "ab" will search for entries starting with
         * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
         * 
         */
        "multiCharSearchDuration": number;
        set(property:"multiCharSearchDuration", value: number): void;
        get(property:"multiCharSearchDuration"): number;
        watch(property:"multiCharSearchDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Tab index of the container; same as HTML tabIndex attribute.
         * Note then when user tabs into the container, focus is immediately
         * moved to the first item in the container.
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * 
         * @param node             
         */
        childSelector(node: HTMLElement): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Deprecated.  You can call this in postCreate() to attach the keyboard handlers to the container,
         * but the preferred method is to override _onLeftArrow() and _onRightArrow(), or
         * _onUpArrow() and _onDownArrow(), to call focusPrev() and focusNext().
         * 
         * @param prevKeyCodes Key codes for navigating to the previous child.             
         * @param nextKeyCodes Key codes for navigating to the next child.             
         */
        connectKeyNavHandlers(prevKeyCodes: dojo.keys, nextKeyCodes: dojo.keys): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Default focus() implementation: focus the first child.
         * 
         */
        focus(): void;
        /**
         * Focus specified child widget.
         * 
         * @param widget Reference to container's child widget             
         * @param last If true and if widget has multiple focusable nodes, focus thelast one instead of the first one             
         */
        focusChild(widget: dijit._WidgetBase, last: boolean): void;
        /**
         * Focus the first focusable child in the container.
         * 
         */
        focusFirstChild(): void;
        /**
         * Focus the last focusable child in the container.
         * 
         */
        focusLastChild(): void;
        /**
         * Focus the next widget
         * 
         */
        focusNext(): void;
        /**
         * Focus the last focusable node in the previous widget
         * (ex: go to the ComboButton icon section rather than button section)
         * 
         */
        focusPrev(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * 
         */
        startupKeyNavChildren(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * When a key is pressed that matches a child item,
         * this method is called so that a widget can take appropriate action is necessary.
         * 
         * @param item             
         * @param evt             
         * @param searchString             
         * @param numMatches             
         */
        onKeyboardSearch(item: dijit._WidgetBase, evt: Event, searchString: String, numMatches: number): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Tooltip.html
     *
     * Pops up a tooltip (a help message) when you hover over a node.
     * Also provides static show() and hide() methods that can be used without instantiating a dijit/Tooltip.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class Tooltip extends dijit._Widget {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Id of domNode(s) to attach the tooltip to.
         * When user hovers over specified dom node(s), the tooltip will appear.
         * 
         */
        "connectId": string;
        set(property:"connectId", value: string): void;
        get(property:"connectId"): string;
        watch(property:"connectId", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This variable controls the position of tooltips, if the position is not specified to
         * the Tooltip widget or *TextBox widget itself.  It's an array of strings with the values
         * possible for dijit/place.around().   The recommended values are:
         * 
         * before-centered: centers tooltip to the left of the anchor node/widget, or to the right
         * in the case of RTL scripts like Hebrew and Arabic
         * after-centered: centers tooltip to the right of the anchor node/widget, or to the left
         * in the case of RTL scripts like Hebrew and Arabic
         * above-centered: tooltip is centered above anchor node
         * below-centered: tooltip is centered above anchor node
         * The list is positions is tried, in order, until a position is found where the tooltip fits
         * within the viewport.
         * 
         * Be careful setting this parameter.  A value of "above-centered" may work fine until the user scrolls
         * the screen so that there's no room above the target node.   Nodes with drop downs, like
         * DropDownButton or FilteringSelect, are especially problematic, in that you need to be sure
         * that the drop down and tooltip don't overlap, even when the viewport is scrolled so that there
         * is only room below (or above) the target node, but not both.
         * 
         */
        "defaultPosition": Object;
        set(property:"defaultPosition", value: Object): void;
        get(property:"defaultPosition"): Object;
        watch(property:"defaultPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML to display in the tooltip.
         * Specified as innerHTML when creating the widget from markup.
         * 
         */
        "label": string;
        set(property:"label", value: string): void;
        get(property:"label"): string;
        watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * See description of dijit/Tooltip.defaultPosition for details on position parameter.
         * 
         */
        "position": Object;
        set(property:"position", value: Object): void;
        get(property:"position"): Object;
        watch(property:"position", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * CSS expression to apply this Tooltip to descendants of connectIds, rather than to
         * the nodes specified by connectIds themselves.    Useful for applying a Tooltip to
         * a range of rows in a table, tree, etc.   Use in conjunction with getContent() parameter.
         * Ex: connectId: myTable, selector: "tr", getContent: function(node){ return ...; }
         * 
         * The application must require() an appropriate level of dojo/query to handle the selector.
         * 
         */
        "selector": Object;
        set(property:"selector", value: Object): void;
        get(property:"selector"): Object;
        watch(property:"selector", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Number of milliseconds to wait after hovering over/focusing on the object, before
         * the tooltip is displayed.
         * 
         */
        "showDelay": number;
        set(property:"showDelay", value: number): void;
        get(property:"showDelay"): number;
        watch(property:"showDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Attach tooltip to specified node if it's not already connected
         * 
         * @param node             
         */
        addTarget(node: HTMLElement): void;
        /**
         * Attach tooltip to specified node if it's not already connected
         * 
         * @param node             
         */
        addTarget(node: String): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * User overridable function that return the text to display in the tooltip.
         * 
         * @param node             
         */
        getContent(node: HTMLElement): any;
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Static method to hide the tooltip displayed via showTooltip()
         * 
         * @param aroundNode             
         */
        hide(aroundNode: any): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Detach tooltip from specified node
         * 
         * @param node             
         */
        removeTarget(node: HTMLElement): void;
        /**
         * Detach tooltip from specified node
         * 
         * @param node             
         */
        removeTarget(node: String): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Static method to display tooltip w/specified contents in specified position.
         * See description of dijit/Tooltip.defaultPosition for details on position parameter.
         * If position is not specified then dijit/Tooltip.defaultPosition is used.
         * 
         * @param innerHTML Contents of the tooltip             
         * @param aroundNode Specifies that tooltip should be next to this node / area             
         * @param position               OptionalList of positions to try to position tooltip (ex: ["right", "above"])             
         * @param rtl               OptionalCorresponds to WidgetBase.dir attribute, where false means "ltr" and truemeans "rtl"; specifies GUI direction, not text direction.             
         * @param textDir               OptionalCorresponds to WidgetBase.textdir attribute; specifies direction of text.             
         */
        show(innerHTML: String, aroundNode: Object, position: String[], rtl: boolean, textDir: String): any;
        /**
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when the tooltip is hidden
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when the tooltip is shown
         * 
         * @param target             
         * @param position             
         */
        onShow(target?: any, position?: any): void;
    }
    module Tooltip {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/Tooltip._MasterTooltip.html
         *
         * Internal widget that holds the actual tooltip markup,
         * which occurs once per page.
         * Called by Tooltip widgets which are just containers to hold
         * the markup
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _MasterTooltip extends dijit._Widget implements dijit._TemplatedMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Milliseconds to fade in/fade out
             * 
             */
            "duration": number;
            set(property:"duration", value: number): void;
            get(property:"duration"): number;
            watch(property:"duration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Hide the tooltip
             * 
             * @param aroundNode             
             */
            hide(aroundNode: any): void;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Private function to set CSS for tooltip node based on which position it's in.
             * This is called by the dijit popup code.   It will also reduce the tooltip's
             * width to whatever width is available
             * 
             * @param node             
             * @param aroundCorner             
             * @param tooltipCorner             
             * @param spaceAvailable             
             * @param aroundNodeCoords             
             */
            orient(node: HTMLElement, aroundCorner: String, tooltipCorner: String, spaceAvailable: Object, aroundNodeCoords: Object): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Display tooltip w/specified contents to right of specified node
             * (To left if there's no space on the right, or if rtl == true)
             * 
             * @param innerHTML Contents of the tooltip             
             * @param aroundNode Specifies that tooltip should be next to this node / area             
             * @param position               OptionalList of positions to try to position tooltip (ex: ["right", "above"])             
             * @param rtl               OptionalCorresponds to WidgetBase.dir attribute, where false means "ltr" and truemeans "rtl"; specifies GUI direction, not text direction.             
             * @param textDir               OptionalCorresponds to WidgetBase.textdir attribute; specifies direction of text.             
             */
            show(innerHTML: String, aroundNode: HTMLElement, position: String[], rtl: boolean, textDir: String): void;
            /**
             * Display tooltip w/specified contents to right of specified node
             * (To left if there's no space on the right, or if rtl == true)
             * 
             * @param innerHTML Contents of the tooltip             
             * @param aroundNode Specifies that tooltip should be next to this node / area             
             * @param position               OptionalList of positions to try to position tooltip (ex: ["right", "above"])             
             * @param rtl               OptionalCorresponds to WidgetBase.dir attribute, where false means "ltr" and truemeans "rtl"; specifies GUI direction, not text direction.             
             * @param textDir               OptionalCorresponds to WidgetBase.textdir attribute; specifies direction of text.             
             */
            show(innerHTML: String, aroundNode:  dijit.place.__Rectangle, position: String[], rtl: boolean, textDir: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/ToolbarSeparator.html
     *
     * A spacer between two dijit.Toolbar items
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class ToolbarSeparator extends dijit._Widget implements dijit._TemplatedMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
         * widget state.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * Destroy this widget, but not its descendants.  Descendants means widgets inside of
         * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
         * 
         * This method will also destroy internal widgets such as those created from a template,
         * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
         * 
         * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
         * depend on the current ability to destroy a widget without destroying its descendants.   Generally
         * they should use destroyRecursive() for widgets with children.
         * 
         * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
         */
        destroy(preserveDom?: boolean): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy this widget and its descendants
         * This is the generic "destructor" function that all widget users
         * should call to cleanly discard with a widget. Once a widget is
         * destroyed, it is removed from the manager object.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * This widget isn't focusable, so pass along that fact.
         * 
         */
        isFocusable(): boolean;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * Called after the parameters to the widget have been read-in,
         * but before the widget template is instantiated. Especially
         * useful to set properties that are referenced in the widget
         * template.
         * 
         */
        postMixInProperties(): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/TitlePane.html
     *
     * A pane with a title on top, that can be expanded or collapsed.
     * An accessible container with a title Heading, and a content
     * section that slides open and closed. TitlePane is an extension to
     * dijit/layout/ContentPane, providing all the useful content-control aspects from it.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class TitlePane extends dijit.layout.ContentPane implements dijit._TemplatedMixin, dijit._CssStateMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * The root className to be placed on this widget's domNode.
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * The innerHTML of the ContentPane.
         * Note that the initialization parameter / argument to set("content", ...)
         * can be a String, DomNode, Nodelist, or _Widget.
         * 
         */
        "content": string;
        set(property:"content", value: string): void;
        get(property:"content"): string;
        watch(property:"content", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Don't change this parameter from the default value.
         * This ContentPane parameter doesn't make sense for TitlePane, since TitlePane
         * is never a child of a layout container, nor should TitlePane try to control
         * the size of an inner widget.
         * 
         */
        "doLayout": boolean;
        set(property:"doLayout", value: boolean): void;
        get(property:"doLayout"): boolean;
        watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Time in milliseconds to fade in/fade out
         * 
         */
        "duration": number;
        set(property:"duration", value: number): void;
        get(property:"duration"): number;
        watch(property:"duration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * Message that shows if an error occurs
         * 
         */
        "errorMessage": string;
        set(property:"errorMessage", value: string): void;
        get(property:"errorMessage"): string;
        watch(property:"errorMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Extract visible content from inside of <body> .... </body>.
         * I.e., strip <html> and <head> (and it's contents) from the href
         * 
         */
        "extractContent": boolean;
        set(property:"extractContent", value: boolean): void;
        get(property:"extractContent"): boolean;
        watch(property:"extractContent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The href of the content that displays now.
         * Set this at construction if you want to load data externally when the
         * pane is shown.  (Set preload=true to load it immediately.)
         * Changing href after creation doesn't have any effect; Use set('href', ...);
         * 
         */
        "href": string;
        set(property:"href", value: string): void;
        get(property:"href"): string;
        watch(property:"href", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Parameters to pass to xhrGet() request, for example:
         * 
         * <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
         * 
         */
        "ioArgs": Object;
        set(property:"ioArgs", value: Object): void;
        get(property:"ioArgs"): Object;
        watch(property:"ioArgs", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Indicates that this widget will call resize() on it's child widgets
         * when they become visible.
         * 
         */
        "isLayoutContainer": boolean;
        set(property:"isLayoutContainer", value: boolean): void;
        get(property:"isLayoutContainer"): boolean;
        watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if the ContentPane has data in it, either specified
         * during initialization (via href or inline content), or set
         * via set('content', ...) / set('href', ...)
         * 
         * False if it doesn't have any content, or if ContentPane is
         * still in the process of downloading href.
         * 
         */
        "isLoaded": boolean;
        set(property:"isLoaded", value: boolean): void;
        get(property:"isLoaded"): boolean;
        watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Message that shows while downloading
         * 
         */
        "loadingMessage": string;
        set(property:"loadingMessage", value: string): void;
        get(property:"loadingMessage"): string;
        watch(property:"loadingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is the dojo.Deferred returned by set('href', ...) and refresh().
         * Calling onLoadDeferred.then() registers your
         * callback to be called only once, when the prior set('href', ...) call or
         * the initial href parameter to the constructor finishes loading.
         * 
         * This is different than an onLoad() handler which gets called any time any href
         * or content is loaded.
         * 
         */
        "onLoadDeferred": Object;
        set(property:"onLoadDeferred", value: Object): void;
        get(property:"onLoadDeferred"): Object;
        watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Whether pane is opened or closed.
         * 
         */
        "open": boolean;
        set(property:"open", value: boolean): void;
        get(property:"open"): boolean;
        watch(property:"open", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Parse content and create the widgets, if any.
         * 
         */
        "parseOnLoad": boolean;
        set(property:"parseOnLoad", value: boolean): void;
        get(property:"parseOnLoad"): boolean;
        watch(property:"parseOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 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 compatibility
         * reasons defaults to dojo._scopeName (which is "dojo" except when
         * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
         * 
         */
        "parserScope": string;
        set(property:"parserScope", value: string): void;
        get(property:"parserScope"): string;
        watch(property:"parserScope", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Force load of data on initialization even if pane is hidden.
         * 
         */
        "preload": boolean;
        set(property:"preload", value: boolean): void;
        get(property:"preload"): boolean;
        watch(property:"preload", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Prevent caching of data from href's by appending a timestamp to the href.
         * 
         */
        "preventCache": boolean;
        set(property:"preventCache", value: boolean): void;
        get(property:"preventCache"): boolean;
        watch(property:"preventCache", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Refresh (re-download) content when pane goes from hidden to shown
         * 
         */
        "refreshOnShow": boolean;
        set(property:"refreshOnShow", value: boolean): void;
        get(property:"refreshOnShow"): boolean;
        watch(property:"refreshOnShow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * 
         */
        "stopParser": boolean;
        set(property:"stopParser", value: boolean): void;
        get(property:"stopParser"): boolean;
        watch(property:"stopParser", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Tabindex setting for the title (so users can tab to the title then
         * use space/enter to open/close the title pane)
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Title of the pane
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Whether pane can be opened or closed by clicking the title bar.
         * 
         */
        "toggleable": boolean;
        set(property:"toggleable", value: boolean): void;
        get(property:"toggleable"): boolean;
        watch(property:"toggleable", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Makes the given widget a child of this widget.
         * Inserts specified child widget's dom node as a child of this widget's
         * container node, and possibly does other processing (such as layout).
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Cancels an in-flight download of content
         * 
         */
        cancel(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * 
         * @param params             
         * @param srcNodeRef             
         */
        create(params: any, srcNodeRef: any): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Destroy all the widgets inside the ContentPane and empty containerNode
         * 
         * @param preserveDom             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy the ContentPane and its contents
         * 
         * @param preserveDom             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Function that should grab the content specified via href.
         * 
         * @param args An object with the following properties:handleAs (String, optional): Acceptable values are: text (default), json, json-comment-optional,json-comment-filtered, javascript, xml. See dojo/_base/xhr.contentHandlerssync (Boolean, optional): false is default. Indicates whether the request shouldbe a synchronous (blocking) request.headers (Object, optional): Additional HTTP headers to send in the request.failOk (Boolean, optional): false is default. Indicates whether a request should beallowed to fail (and therefore no console error message inthe event of a failure)contentType (String|Boolean): "application/x-www-form-urlencoded" is default. Set to false toprevent a Content-Type header from being sent, or to a stringto send a different Content-Type.load: This function will becalled on a successful HTTP response code.error: This function willbe called when the request fails due to a network or server error, the urlis invalid, etc. It will also be called if the load or handle callback throws anexception, unless djConfig.debugAtAllCosts is true.  This allows deployed applicationsto continue to run even when a logic error happens in the callback, while makingit easier to troubleshoot while in debug mode.handle: This function willbe called at the end of every request, whether or not an error occurs.url (String): URL to server endpoint.content (Object, optional): Contains properties with string values. Theseproperties will be serialized as name1=value2 andpassed in the request.timeout (Integer, optional): Milliseconds to wait for the response. If this timepasses, the then error callbacks are called.form (DOMNode, optional): DOM node for a form. Used to extract the form valuesand send to the server.preventCache (Boolean, optional): Default is false. If true, then a"dojo.preventCache" parameter is sent in the requestwith a value that changes with each request(timestamp). Useful only with GET-type requests.rawBody (String, optional): Sets the raw body for an HTTP request. If this is used, then the contentproperty is ignored. This is mostly useful for HTTP methods that havea body to their requests, like PUT or POST. This property can be used insteadof postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.ioPublish (Boolean, optional): Set this explicitly to false to prevent publishing of topics related toIO operations. Otherwise, if djConfig.ioPublish is set to true, topicswill be published via dojo/topic.publish() for different phases of an IO operation.See dojo/main.__IoPublish for a list of topics that are published.            
         */
        ioMethod(args: Object): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * 
         * @param params             
         * @param node             
         * @param ctor             
         */
        markupFactory(params: any, node: any, ctor: any): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * 
         */
        postMixInProperties(): void;
        /**
         * [Re]download contents of href and display
         * cancels any currently in-flight requests
         * posts "loading..." message
         * sends XHR to download new data
         * 
         */
        refresh(): any;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * See dijit/layout/_LayoutWidget.resize() for description.
         * Although ContentPane doesn't extend _LayoutWidget, it does implement
         * the same API.
         * 
         * @param changeSize             
         * @param resultSize             
         */
        resize(changeSize: any, resultSize: any): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: String): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: HTMLElement): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: NodeList): void;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: String): any;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: URL): any;
        /**
         * Deprecated.  Use set('title', ...) instead.
         * 
         * @param title             
         */
        setTitle(title: String): void;
        /**
         * Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when this widget is being displayed as a popup (ex: a Calendar popped
         * up from a DateTextBox), and it is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
         * Callback if a user tries to close the child.   Child will be closed if this function returns true.
         * 
         */
        onClose(): boolean;
        /**
         * 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.
         * 
         * @param error             
         */
        onContentError(error: Error): void;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when download is finished.
         * 
         */
        onDownloadEnd(): 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.
         * 
         * @param error             
         */
        onDownloadError(error: Error): any;
        /**
         * Called before download starts.
         * The string returned by this function will be the html
         * that tells the user we are loading something.
         * Override with your own function if you want to change text.
         * 
         */
        onDownloadStart(): any;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Event hook, is called after everything is loaded and widgetified
         * 
         * @param data             
         */
        onLoad(data: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
        /**
         * Event hook, is called before old content is cleared
         * 
         */
        onUnload(): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/TooltipDialog.html
     *
     * Pops up a dialog that appears like a Tooltip
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class TooltipDialog extends dijit.layout.ContentPane implements dijit._TemplatedMixin, dijit.form._FormMixin, dijit._DialogMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * A Toggle to modify the default focus behavior of a Dialog, which
         * is to focus on the first dialog element after opening the dialog.
         * False will disable autofocusing.  Default: true.
         * 
         */
        "autofocus": boolean;
        set(property:"autofocus", value: boolean): void;
        get(property:"autofocus"): boolean;
        watch(property:"autofocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The root className to use for the various states of this widget
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * The innerHTML of the ContentPane.
         * Note that the initialization parameter / argument to set("content", ...)
         * can be a String, DomNode, Nodelist, or _Widget.
         * 
         */
        "content": string;
        set(property:"content", value: string): void;
        get(property:"content"): string;
        watch(property:"content", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Don't change this parameter from the default value.
         * This ContentPane parameter doesn't make sense for TooltipDialog, since TooltipDialog
         * is never a child of a layout container, nor can you specify the size of
         * TooltipDialog in order to control the size of an inner widget.
         * 
         */
        "doLayout": boolean;
        set(property:"doLayout", value: boolean): void;
        get(property:"doLayout"): boolean;
        watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Message that shows if an error occurs
         * 
         */
        "errorMessage": string;
        set(property:"errorMessage", value: string): void;
        get(property:"errorMessage"): string;
        watch(property:"errorMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Extract visible content from inside of <body> .... </body>.
         * I.e., strip <html> and <head> (and it's contents) from the href
         * 
         */
        "extractContent": boolean;
        set(property:"extractContent", value: boolean): void;
        get(property:"extractContent"): boolean;
        watch(property:"extractContent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The href of the content that displays now.
         * Set this at construction if you want to load data externally when the
         * pane is shown.  (Set preload=true to load it immediately.)
         * Changing href after creation doesn't have any effect; Use set('href', ...);
         * 
         */
        "href": string;
        set(property:"href", value: string): void;
        get(property:"href"): string;
        watch(property:"href", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Parameters to pass to xhrGet() request, for example:
         * 
         * <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
         * 
         */
        "ioArgs": Object;
        set(property:"ioArgs", value: Object): void;
        get(property:"ioArgs"): Object;
        watch(property:"ioArgs", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Indicates that this widget will call resize() on it's child widgets
         * when they become visible.
         * 
         */
        "isLayoutContainer": boolean;
        set(property:"isLayoutContainer", value: boolean): void;
        get(property:"isLayoutContainer"): boolean;
        watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * True if the ContentPane has data in it, either specified
         * during initialization (via href or inline content), or set
         * via set('content', ...) / set('href', ...)
         * 
         * False if it doesn't have any content, or if ContentPane is
         * still in the process of downloading href.
         * 
         */
        "isLoaded": boolean;
        set(property:"isLoaded", value: boolean): void;
        get(property:"isLoaded"): boolean;
        watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Message that shows while downloading
         * 
         */
        "loadingMessage": string;
        set(property:"loadingMessage", value: string): void;
        get(property:"loadingMessage"): string;
        watch(property:"loadingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This is the dojo.Deferred returned by set('href', ...) and refresh().
         * Calling onLoadDeferred.then() registers your
         * callback to be called only once, when the prior set('href', ...) call or
         * the initial href parameter to the constructor finishes loading.
         * 
         * This is different than an onLoad() handler which gets called any time any href
         * or content is loaded.
         * 
         */
        "onLoadDeferred": Object;
        set(property:"onLoadDeferred", value: Object): void;
        get(property:"onLoadDeferred"): Object;
        watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Parse content and create the widgets, if any.
         * 
         */
        "parseOnLoad": boolean;
        set(property:"parseOnLoad", value: boolean): void;
        get(property:"parseOnLoad"): boolean;
        watch(property:"parseOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 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 compatibility
         * reasons defaults to dojo._scopeName (which is "dojo" except when
         * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
         * 
         */
        "parserScope": string;
        set(property:"parserScope", value: string): void;
        get(property:"parserScope"): string;
        watch(property:"parserScope", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Force load of data on initialization even if pane is hidden.
         * 
         */
        "preload": boolean;
        set(property:"preload", value: boolean): void;
        get(property:"preload"): boolean;
        watch(property:"preload", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Prevent caching of data from href's by appending a timestamp to the href.
         * 
         */
        "preventCache": boolean;
        set(property:"preventCache", value: boolean): void;
        get(property:"preventCache"): boolean;
        watch(property:"preventCache", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Refresh (re-download) content when pane goes from hidden to shown
         * 
         */
        "refreshOnShow": boolean;
        set(property:"refreshOnShow", value: boolean): void;
        get(property:"refreshOnShow"): boolean;
        watch(property:"refreshOnShow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Will be "Error" if one or more of the child widgets has an invalid value,
         * "Incomplete" if not all of the required child widgets are filled in.  Otherwise, "",
         * which indicates that the form is ready to be submitted.
         * 
         */
        "state": string;
        set(property:"state", value: string): void;
        get(property:"state"): string;
        watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "stopParser": boolean;
        set(property:"stopParser", value: boolean): void;
        get(property:"stopParser"): boolean;
        watch(property:"stopParser", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Description of tooltip dialog (required for a11y)
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Makes the given widget a child of this widget.
         * Inserts specified child widget's dom node as a child of this widget's
         * container node, and possibly does other processing (such as layout).
         * 
         * @param widget             
         * @param insertIndex               Optional            
         */
        addChild(widget: dijit._WidgetBase, insertIndex: number): void;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * 
         */
        buildRendering(): void;
        /**
         * Cancels an in-flight download of content
         * 
         */
        cancel(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * You can call this function directly, ex. in the event that you
         * programmatically add a widget to the form after the form has been
         * initialized.
         * 
         * @param inStartup             
         */
        connectChildren(inStartup: boolean): void;
        /**
         * 
         * @param params             
         * @param srcNodeRef             
         */
        create(params: any, srcNodeRef: any): void;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Destroy all the widgets inside the ContentPane and empty containerNode
         * 
         * @param preserveDom             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * Destroy the ContentPane and its contents
         * 
         * @param preserveDom             
         */
        destroyRecursive(preserveDom?: boolean): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Deprecated method.   Applications no longer need to call this.   Remove for 2.0.
         * 
         */
        disconnectChildren(): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Callback when the user hits the submit button.
         * Override this method to handle Dialog execution.
         * After the user has pressed the submit button, the Dialog
         * first calls onExecute() to notify the container to hide the
         * dialog and restore focus to wherever it used to be.
         * 
         * Then this method is called.
         * 
         * @param formContents             
         */
        execute(formContents: Object): void;
        /**
         * Focus on first field
         * 
         */
        focus(): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Gets the index of the child in this container or -1 if not found
         * 
         * @param child             
         */
        getIndexOfChild(child: dijit._WidgetBase): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * 
         */
        getValues(): any;
        /**
         * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
         * 
         */
        hasChildren(): boolean;
        /**
         * Function that should grab the content specified via href.
         * 
         * @param args An object with the following properties:handleAs (String, optional): Acceptable values are: text (default), json, json-comment-optional,json-comment-filtered, javascript, xml. See dojo/_base/xhr.contentHandlerssync (Boolean, optional): false is default. Indicates whether the request shouldbe a synchronous (blocking) request.headers (Object, optional): Additional HTTP headers to send in the request.failOk (Boolean, optional): false is default. Indicates whether a request should beallowed to fail (and therefore no console error message inthe event of a failure)contentType (String|Boolean): "application/x-www-form-urlencoded" is default. Set to false toprevent a Content-Type header from being sent, or to a stringto send a different Content-Type.load: This function will becalled on a successful HTTP response code.error: This function willbe called when the request fails due to a network or server error, the urlis invalid, etc. It will also be called if the load or handle callback throws anexception, unless djConfig.debugAtAllCosts is true.  This allows deployed applicationsto continue to run even when a logic error happens in the callback, while makingit easier to troubleshoot while in debug mode.handle: This function willbe called at the end of every request, whether or not an error occurs.url (String): URL to server endpoint.content (Object, optional): Contains properties with string values. Theseproperties will be serialized as name1=value2 andpassed in the request.timeout (Integer, optional): Milliseconds to wait for the response. If this timepasses, the then error callbacks are called.form (DOMNode, optional): DOM node for a form. Used to extract the form valuesand send to the server.preventCache (Boolean, optional): Default is false. If true, then a"dojo.preventCache" parameter is sent in the requestwith a value that changes with each request(timestamp). Useful only with GET-type requests.rawBody (String, optional): Sets the raw body for an HTTP request. If this is used, then the contentproperty is ignored. This is mostly useful for HTTP methods that havea body to their requests, like PUT or POST. This property can be used insteadof postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.ioPublish (Boolean, optional): Set this explicitly to false to prevent publishing of topics related toIO operations. Otherwise, if djConfig.ioPublish is set to true, topicswill be published via dojo/topic.publish() for different phases of an IO operation.See dojo/main.__IoPublish for a list of topics that are published.            
         */
        ioMethod(args: Object): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * Returns true if all of the widgets are valid.
         * Deprecated, will be removed in 2.0.  Use get("state") instead.
         * 
         */
        isValid: {(): boolean};
        /**
         * 
         * @param params             
         * @param node             
         * @param ctor             
         */
        markupFactory(params: any, node: any, ctor: any): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Configure widget to be displayed in given position relative to the button.
         * This is called from the dijit.popup code, and should not be called
         * directly.
         * 
         * @param node             
         * @param aroundCorner             
         * @param tooltipCorner             
         */
        orient(node: HTMLElement, aroundCorner: String, tooltipCorner: String): void;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * 
         */
        postMixInProperties(): void;
        /**
         * [Re]download contents of href and display
         * cancels any currently in-flight requests
         * posts "loading..." message
         * sends XHR to download new data
         * 
         */
        refresh(): any;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: dijit._WidgetBase): void;
        /**
         * Removes the passed widget instance from this widget but does
         * not destroy it.  You can also pass in an integer indicating
         * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
         * 
         * @param widget             
         */
        removeChild(widget: number): void;
        /**
         * 
         */
        reset(): void;
        /**
         * See dijit/layout/_LayoutWidget.resize() for description.
         * Although ContentPane doesn't extend _LayoutWidget, it does implement
         * the same API.
         * 
         * @param changeSize             
         * @param resultSize             
         */
        resize(changeSize: any, resultSize: any): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: String): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: HTMLElement): void;
        /**
         * Deprecated.   Use set('content', ...) instead.
         * 
         * @param data             
         */
        setContent(data: NodeList): void;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: String): any;
        /**
         * Deprecated.   Use set('href', ...) instead.
         * 
         * @param href             
         */
        setHref(href: URL): any;
        /**
         * 
         * @param val             
         */
        setValues(val: any): any;
        /**
         * Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * returns if the form is valid - same as isValid - but
         * provides a few additional (ui-specific) features:
         * 
         * it will highlight any sub-widgets that are not valid
         * it will call focus() on the first invalid sub-widget
         * 
         */
        validate(): any;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Called when user has pressed the Dialog's cancel button, to notify container.
         * Developer shouldn't override or connect to this method;
         * it's a private communication device between the TooltipDialog
         * and the thing that opened it (ex: dijit/form/DropDownButton)
         * 
         */
        onCancel(): void;
        /**
         * Connect to this function to receive notifications of mouse click events.
         * 
         * @param event mouse Event             
         */
        onClick(event: any): void;
        /**
         * Called when dialog is hidden.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         */
        onClose(): boolean;
        /**
         * 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.
         * 
         * @param error             
         */
        onContentError(error: Error): void;
        /**
         * Connect to this function to receive notifications of mouse double click events.
         * 
         * @param event mouse Event             
         */
        onDblClick(event: any): void;
        /**
         * Called when download is finished.
         * 
         */
        onDownloadEnd(): 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.
         * 
         * @param error             
         */
        onDownloadError(error: Error): any;
        /**
         * Called before download starts.
         * The string returned by this function will be the html
         * that tells the user we are loading something.
         * Override with your own function if you want to change text.
         * 
         */
        onDownloadStart(): any;
        /**
         * Called when user has pressed the dialog's OK button, to notify container.
         * Developer shouldn't override or connect to this method;
         * it's a private communication device between the TooltipDialog
         * and the thing that opened it (ex: dijit/form/DropDownButton)
         * 
         */
        onExecute(): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Event hook, is called after everything is loaded and widgetified
         * 
         * @param data             
         */
        onLoad(data: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Called when dialog is displayed.
         * This is called from the dijit.popup code, and should not be called directly.
         * 
         * @param pos             
         */
        onOpen(pos: Object): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
        /**
         * Event hook, is called before old content is cleared
         * 
         */
        onUnload(): void;
        /**
         * Stub function to connect to if you want to do something
         * (like disable/enable a submit button) when the valid
         * state changes on the form as a whole.
         * 
         * Deprecated.  Will be removed in 2.0.  Use watch("state", ...) instead.
         * 
         * @param isValid             
         */
        onValidStateChange(isValid: boolean): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/WidgetSet.html
     *
     * A set of widgets indexed by id.
     * Deprecated, will be removed in 2.0.
     * 
     */
    class WidgetSet {
        constructor();
        /**
         * Add a widget to this list. If a duplicate ID is detected, a error is thrown.
         * 
         * @param widget Any dijit/_WidgetBase subclass.             
         */
        add(widget: dijit._WidgetBase): void;
        /**
         * Reduce this widgetset to a new WidgetSet of a particular declaredClass
         * 
         * @param cls The Class to scan for. Full dot-notated string.             
         */
        byClass(cls: String): any;
        /**
         * Find a widget in this list by it's id.
         * 
         * @param id             
         */
        byId(id: String): dijit._WidgetBase;
        /**
         * A synthetic clone of array.every acting explicitly on this WidgetSet
         * 
         * @param func A callback function run for every widget in this list. Exits loopwhen the first false return is encountered.             
         * @param thisObj               OptionalOptional scope parameter to use for the callback             
         */
        every(func: Function, thisObj: Object): boolean;
        /**
         * Filter down this WidgetSet to a smaller new WidgetSet
         * Works the same as array.filter and NodeList.filter
         * 
         * @param filter Callback function to test truthiness. Is passed the widgetreference and the pseudo-index in the object.             
         * @param thisObj               OptionalOption scope to use for the filter function.             
         */
        filter(filter: Function, thisObj: Object): any;
        /**
         * Call specified function for each widget in this set.
         * 
         * @param func A callback function to run for each item. Is passed the widget, the indexin the iteration, and the full hash, similar to array.forEach.             
         * @param thisObj               OptionalAn optional scope parameter             
         */
        forEach(func: Function, thisObj: Object): any;
        /**
         * Create a new Array from this WidgetSet, following the same rules as array.map
         * 
         * @param func             
         * @param thisObj               Optional            
         */
        map(func: Function, thisObj: Object): any;
        /**
         * Remove a widget from this WidgetSet. Does not destroy the widget; simply
         * removes the reference.
         * 
         * @param id             
         */
        remove(id: String): void;
        /**
         * A synthetic clone of array.some acting explicitly on this WidgetSet
         * 
         * @param func A callback function run for every widget in this list. Exits loopwhen the first true return is encountered.             
         * @param thisObj               OptionalOptional scope parameter to use for the callback             
         */
        some(func: Function, thisObj: Object): boolean;
        /**
         * Convert this WidgetSet into a true Array
         * 
         */
        toArray(): any[];
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Tree.html
     *
     * This widget displays hierarchical data from a store.
     * 
     * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
     * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
     */
    class Tree extends dijit._Widget implements dijit._KeyNavMixin, dijit._TemplatedMixin, dijit._CssStateMixin {
        constructor(params?: Object, srcNodeRef?: HTMLElement);
        /**
         * True if mouse was pressed while over this widget, and hasn't been released yet
         * 
         */
        "active": boolean;
        set(property:"active", value: boolean): void;
        get(property:"active"): boolean;
        watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Object to which attach points and events will be scoped.  Defaults
         * to 'this'.
         * 
         */
        "attachScope": Object;
        set(property:"attachScope", value: Object): void;
        get(property:"attachScope"): Object;
        watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
         * for each XXX attribute to be mapped to the DOM.
         * 
         * attributeMap sets up a "binding" between attributes (aka properties)
         * of the widget and the widget's DOM.
         * Changes to widget attributes listed in attributeMap will be
         * reflected into the DOM.
         * 
         * For example, calling set('title', 'hello')
         * on a TitlePane will automatically cause the TitlePane's DOM to update
         * with the new title.
         * 
         * attributeMap is a hash where the key is an attribute of the widget,
         * and the value reflects a binding to a:
         * 
         * DOM node attribute
         *   focus: {node: "focusNode", type: "attribute"}
         * Maps this.focus to this.focusNode.focus
         * 
         * DOM node innerHTML
         *   title: { node: "titleNode", type: "innerHTML" }
         * Maps this.title to this.titleNode.innerHTML
         * 
         * DOM node innerText
         *   title: { node: "titleNode", type: "innerText" }
         * Maps this.title to this.titleNode.innerText
         * 
         * DOM node CSS class
         *   myClass: { node: "domNode", type: "class" }
         * Maps this.myClass to this.domNode.className
         * 
         * If the value is an array, then each element in the array matches one of the
         * formats of the above list.
         * 
         * There are also some shorthands for backwards compatibility:
         * 
         * string --> { node: string, type: "attribute" }, for example:
         * "focusNode" ---> { node: "focusNode", type: "attribute" }
         * "" --> { node: "domNode", type: "attribute" }
         * 
         */
        "attributeMap": Object;
        set(property:"attributeMap", value: Object): void;
        get(property:"attributeMap"): Object;
        watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Fully expand the tree on load.   Overrides persist.
         * 
         */
        "autoExpand": boolean;
        set(property:"autoExpand", value: boolean): void;
        get(property:"autoExpand"): boolean;
        watch(property:"autoExpand", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * 
         */
        "baseClass": string;
        set(property:"baseClass", value: string): void;
        get(property:"baseClass"): string;
        watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Set to a positive value to allow drag and drop "between" nodes.
         * 
         * If during DnD mouse is over a (target) node but less than betweenThreshold
         * pixels from the bottom edge, dropping the the dragged node will make it
         * the next sibling of the target node, rather than the child.
         * 
         * Similarly, if mouse is over a target node but less that betweenThreshold
         * pixels from the top edge, dropping the dragged node will make it
         * the target node's previous sibling rather than the target node's child.
         * 
         */
        "betweenThreshold": number;
        set(property:"betweenThreshold", value: number): void;
        get(property:"betweenThreshold"): number;
        watch(property:"betweenThreshold", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * 
         */
        "checkAcceptance": Object;
        set(property:"checkAcceptance", value: Object): void;
        get(property:"checkAcceptance"): Object;
        watch(property:"checkAcceptance", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "checkItemAcceptance": Object;
        set(property:"checkItemAcceptance", value: Object): void;
        get(property:"checkItemAcceptance"): Object;
        watch(property:"checkItemAcceptance", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Deprecated.   This information should be specified in the model.
         * One ore more attributes that holds children of a tree node
         * 
         */
        "childrenAttr": Object;
        set(property:"childrenAttr", value: Object): void;
        get(property:"childrenAttr"): Object;
        watch(property:"childrenAttr", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "childSelector": string;
        set(property:"childSelector", value: string): void;
        get(property:"childSelector"): string;
        watch(property:"childSelector", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "class": string;
        set(property:"class", value: string): void;
        get(property:"class"): string;
        watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Designates where children of the source DOM node will be placed.
         * "Children" in this case refers to both DOM nodes and widgets.
         * For example, for myWidget:
         * 
         * <div data-dojo-type=myWidget>
         *     <b> here's a plain DOM node
         *     <span data-dojo-type=subWidget>and a widget</span>
         *     <i> and another plain DOM node </i>
         * </div>
         * containerNode would point to:
         * 
         * <b> here's a plain DOM node
         * <span data-dojo-type=subWidget>and a widget</span>
         * <i> and another plain DOM node </i>
         * In templated widgets, "containerNode" is set via a
         * data-dojo-attach-point assignment.
         * 
         * containerNode must be defined for any widget that accepts innerHTML
         * (like ContentPane or BorderContainer or even Button), and conversely
         * is null for widgets that don't, like TextBox.
         * 
         */
        "containerNode": HTMLElement;
        set(property:"containerNode", value: HTMLElement): void;
        get(property:"containerNode"): HTMLElement;
        watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
         * need CSS classes applied on mouse hover/press and focus.
         * 
         * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
         * (like "dijitUpArrowButton"). Example:
         * 
         * {
         *     "upArrowButton": "dijitUpArrowButton",
         *     "downArrowButton": "dijitDownArrowButton"
         * }
         * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
         * 
         * is hovered, etc.
         * 
         */
        "cssStateNodes": Object;
        set(property:"cssStateNodes", value: Object): void;
        get(property:"cssStateNodes"): Object;
        watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Bi-directional support, as defined by the HTML DIR
         * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
         * default direction.
         * 
         */
        "dir": string;
        set(property:"dir", value: string): void;
        get(property:"dir"): string;
        watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "dndParams": any[];
        set(property:"dndParams", value: any[]): void;
        get(property:"dndParams"): any[];
        watch(property:"dndParams", callback:{(property?:string, oldValue?:any[], newValue?: any[]):void}) :{unwatch():void}
        /**
         * This is our visible representation of the widget! Other DOM
         * Nodes may by assigned to other properties, usually through the
         * template system's data-dojo-attach-point syntax, but the domNode
         * property is the canonical "top level" node in widget UI.
         * 
         */
        "domNode": HTMLElement;
        set(property:"domNode", value: HTMLElement): void;
        get(property:"domNode"): HTMLElement;
        watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Number of pixels mouse moves before it's considered the start of a drag operation
         * 
         */
        "dragThreshold": number;
        set(property:"dragThreshold", value: number): void;
        get(property:"dragThreshold"): number;
        watch(property:"dragThreshold", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * This widget or a widget it contains has focus, or is "active" because
         * it was recently clicked.
         * 
         */
        "focused": boolean;
        set(property:"focused", value: boolean): void;
        get(property:"focused"): boolean;
        watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The currently focused child widget, or null if there isn't one
         * 
         */
        "focusedChild": Object;
        set(property:"focusedChild", value: Object): void;
        get(property:"focusedChild"): Object;
        watch(property:"focusedChild", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * True if cursor is over this widget
         * 
         */
        "hovering": boolean;
        set(property:"hovering", value: boolean): void;
        get(property:"hovering"): boolean;
        watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * A unique, opaque ID string that can be assigned by users or by the
         * system. If the developer passes an ID which is known not to be
         * unique, the specified ID is ignored and the system-generated ID is
         * used instead.
         * 
         */
        "id": string;
        set(property:"id", value: string): void;
        get(property:"id"): string;
        watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Deprecated.  Use dijit/tree/ForestStoreModel directly instead.
         * Used in conjunction with query parameter.
         * If a query is specified (rather than a root node id), and a label is also specified,
         * then a fake root node is created and displayed, with this label.
         * 
         */
        "label": string;
        set(property:"label", value: string): void;
        get(property:"label"): string;
        watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Rarely used.  Overrides the default Dojo locale used to render this widget,
         * as defined by the HTML LANG attribute.
         * Value must be among the list of locales specified during by the Dojo bootstrap,
         * formatted according to RFC 3066 (like en-us).
         * 
         */
        "lang": string;
        set(property:"lang", value: string): void;
        get(property:"lang"): string;
        watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Interface to read tree data, get notifications of changes to tree data,
         * and for handling drop operations (i.e drag and drop onto the tree)
         * 
         */
        "model": Object;
        set(property:"model", value: Object): void;
        get(property:"model"): Object;
        watch(property:"model", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * If multiple characters are typed where each keystroke happens within
         * multiCharSearchDuration of the previous keystroke,
         * search for nodes matching all the keystrokes.
         * 
         * For example, typing "ab" will search for entries starting with
         * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
         * 
         */
        "multiCharSearchDuration": number;
        set(property:"multiCharSearchDuration", value: number): void;
        get(property:"multiCharSearchDuration"): number;
        watch(property:"multiCharSearchDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
        /**
         * Parameter to dndController, see dijit/tree/dndSource.onDndCancel().
         * Generally this doesn't need to be set.
         * 
         */
        "onDndCancel": Function;
        set(property:"onDndCancel", value: Function): void;
        get(property:"onDndCancel"): Function;
        watch(property:"onDndCancel", callback:{(property?:string, oldValue?:Function, newValue?: Function):void}) :{unwatch():void}
        /**
         * Parameter to dndController, see dijit/tree/dndSource.onDndDrop().
         * Generally this doesn't need to be set.
         * 
         */
        "onDndDrop": Function;
        set(property:"onDndDrop", value: Function): void;
        get(property:"onDndDrop"): Function;
        watch(property:"onDndDrop", callback:{(property?:string, oldValue?:Function, newValue?: Function):void}) :{unwatch():void}
        /**
         * If true, clicking a folder node's label will open it, rather than calling onClick()
         * 
         */
        "openOnClick": boolean;
        set(property:"openOnClick", value: boolean): void;
        get(property:"openOnClick"): boolean;
        watch(property:"openOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * If true, double-clicking a folder node's label will open it, rather than calling onDblClick()
         * 
         */
        "openOnDblClick": boolean;
        set(property:"openOnDblClick", value: boolean): void;
        get(property:"openOnDblClick"): boolean;
        watch(property:"openOnDblClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * The document this widget belongs to.  If not specified to constructor, will default to
         * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
         * 
         */
        "ownerDocument": Object;
        set(property:"ownerDocument", value: Object): void;
        get(property:"ownerDocument"): Object;
        watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Backward compatible singular variant of paths.
         * 
         */
        "path": any[];
        set(property:"path", value: any[]): void;
        get(property:"path"): any[];
        watch(property:"path", callback:{(property?:string, oldValue?:any[], newValue?: any[]):void}) :{unwatch():void}
        /**
         * 
         */
        "PathError": Object;
        set(property:"PathError", value: Object): void;
        get(property:"PathError"): Object;
        watch(property:"PathError", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Full paths from rootNode to selected nodes expressed as array of items or array of ids.
         * Since setting the paths may be asynchronous (because of waiting on dojo.data), set("paths", ...)
         * returns a Promise to indicate when the set is complete.
         * 
         */
        "paths": any[];
        set(property:"paths", value: any[]): void;
        get(property:"paths"): any[];
        watch(property:"paths", callback:{(property?:string, oldValue?:any[], newValue?: any[]):void}) :{unwatch():void}
        /**
         * Enables/disables use of cookies for state saving.
         * 
         */
        "persist": boolean;
        set(property:"persist", value: boolean): void;
        get(property:"persist"): boolean;
        watch(property:"persist", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Deprecated.  User should specify query to the model directly instead.
         * Specifies datastore query to return the root item or top items for the tree.
         * 
         */
        "query": Object;
        set(property:"query", value: Object): void;
        get(property:"query"): Object;
        watch(property:"query", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * 
         */
        "searchContainerNode": boolean;
        set(property:"searchContainerNode", value: boolean): void;
        get(property:"searchContainerNode"): boolean;
        watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * Backward compatible singular variant of selectedItems.
         * 
         */
        "selectedItem": Object;
        set(property:"selectedItem", value: Object): void;
        get(property:"selectedItem"): Object;
        watch(property:"selectedItem", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * The currently selected items in this tree.
         * This property can only be set (via set('selectedItems', ...)) when that item is already
         * visible in the tree.   (I.e. the tree has already been expanded to show that node.)
         * Should generally use paths attribute to set the selected items instead.
         * 
         */
        "selectedItems": Object;
        set(property:"selectedItems", value: Object): void;
        get(property:"selectedItems"): Object;
        watch(property:"selectedItems", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
        /**
         * Should the root node be displayed, or hidden?
         * 
         */
        "showRoot": boolean;
        set(property:"showRoot", value: boolean): void;
        get(property:"showRoot"): boolean;
        watch(property:"showRoot", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
        /**
         * pointer to original DOM node
         * 
         */
        "srcNodeRef": HTMLElement;
        set(property:"srcNodeRef", value: HTMLElement): void;
        get(property:"srcNodeRef"): HTMLElement;
        watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
        /**
         * Deprecated.  Use "model" parameter instead.
         * The store to get data to display in the tree.
         * 
         */
        "store": string;
        set(property:"store", value: string): void;
        get(property:"store"): string;
        watch(property:"store", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML style attributes as cssText string or name/value hash
         * 
         */
        "style": string;
        set(property:"style", value: string): void;
        get(property:"style"): string;
        watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Tab index of the container; same as HTML tabIndex attribute.
         * Note then when user tabs into the container, focus is immediately
         * moved to the first item in the container.
         * 
         */
        "tabIndex": string;
        set(property:"tabIndex", value: string): void;
        get(property:"tabIndex"): string;
        watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * Path to template (HTML file) for this widget relative to dojo.baseUrl.
         * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
         * 
         */
        "templatePath": string;
        set(property:"templatePath", value: string): void;
        get(property:"templatePath"): string;
        watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * 
         */
        "templateString": string;
        set(property:"templateString", value: string): void;
        get(property:"templateString"): string;
        watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * HTML title attribute.
         * 
         * For form widgets this specifies a tooltip to display when hovering over
         * the widget (just like the native HTML title attribute).
         * 
         * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
         * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
         * interpreted as HTML.
         * 
         */
        "title": string;
        set(property:"title", value: string): void;
        get(property:"title"): string;
        watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
         * this specifies the tooltip to appear when the mouse is hovered over that text.
         * 
         */
        "tooltip": string;
        set(property:"tooltip", value: string): void;
        get(property:"tooltip"): string;
        watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: String, value: Object): any;
        /**
         * This method is deprecated, use get() or set() directly.
         * 
         * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
         * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
         */
        attr(name: Object, value: Object): any;
        /**
         * Construct the UI for this widget, setting this.domNode.
         * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
         * 
         */
        buildRendering(): void;
        /**
         * Collapse all nodes in the tree
         * 
         */
        collapseAll(): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: String): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: String, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: Object, event: Function, method: Function): any;
        /**
         * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
         * 
         * Connects specified obj/event to specified method of this object
         * and registers for disconnect() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.connect, except with the
         * implicit use of this widget as the target object.
         * Events connected with this.connect are disconnected upon
         * destruction.
         * 
         * @param obj             
         * @param event             
         * @param method             
         */
        connect(obj: any, event: Function, method: Function): any;
        /**
         * Wrapper to setTimeout to avoid deferred functions executing
         * after the originating widget has been destroyed.
         * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
         * 
         * @param fcn Function reference.             
         * @param delay               OptionalDelay, defaults to 0.             
         */
        defer(fcn: Function, delay: number): Object;
        /**
         * 
         */
        destroy(): void;
        /**
         * Recursively destroy the children of this widget and their
         * descendants.
         * 
         * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
         */
        destroyDescendants(preserveDom?: boolean): void;
        /**
         * 
         */
        destroyRecursive(): void;
        /**
         * Destroys the DOM nodes associated with this widget.
         * 
         * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
         */
        destroyRendering(preserveDom?: boolean): void;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Disconnects handle created by connect.
         * 
         * @param handle             
         */
        disconnect(handle: any): void;
        /**
         * Class to use as as the dnd controller.  Specifying this class enables DnD.
         * Generally you should specify this as dijit/tree/dndSource.
         * Setting of dijit/tree/_dndSelector handles selection only (no actual DnD).
         * 
         */
        dndController(): void;
        /**
         * Used by widgets to signal that a synthetic event occurred, ex:
         * 
         * myWidget.emit("attrmodified-selectedChildWidget", {}).
         * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
         * Also calls onType() method, if present, and returns value from that method.
         * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
         * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
         * 
         * @param type             
         * @param eventObj               Optional            
         * @param callbackArgs               Optional            
         */
        emit(type: String, eventObj: Object, callbackArgs: any[]): any;
        /**
         * Expand all nodes in the tree
         * 
         */
        expandAll(): any;
        /**
         * Default focus() implementation: focus the previously focused child, or first child.
         * Some applications may want to change this method to focus the [first] selected child.
         * 
         */
        focus(): void;
        /**
         * Focus specified child widget.
         * 
         * @param widget Reference to container's child widget             
         * @param last If true and if widget has multiple focusable nodes, focus thelast one instead of the first one             
         */
        focusChild(widget: dijit._WidgetBase, last: boolean): void;
        /**
         * Focus the first focusable child in the container.
         * 
         */
        focusFirstChild(): void;
        /**
         * End key pressed; go to last visible node.
         * 
         */
        focusLastChild(): void;
        /**
         * Focus on the specified node (which must be visible)
         * 
         * @param node             
         */
        focusNode(node: dijit.Tree._TreeNode): void;
        /**
         * Get a property from a widget.
         * Get a named property from a widget. The property may
         * potentially be retrieved via a getter method. If no getter is defined, this
         * just retrieves the object's property.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _getFooAttr(), calling:
         * myWidget.get("foo") would be equivalent to calling
         * widget._getFooAttr() and myWidget.get("bar")
         * would be equivalent to the expression
         * widget.bar2
         * 
         * @param name The property to get.             
         */
        get(name: any): any;
        /**
         * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
         * is this widget.   Note that it does not return all descendants, but rather just direct children.
         * Analogous to Node.childNodes,
         * except containing widgets rather than DOMNodes.
         * 
         * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
         * outside of this.containerNode.
         * 
         * Note that the array returned is a simple array.  Application code should not assume
         * existence of methods like forEach().
         * 
         */
        getChildren(): any[];
        /**
         * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
         * This method should generally be avoided as it returns widgets declared in templates, which are
         * supposed to be internal/hidden, but it's left here for back-compat reasons.
         * 
         */
        getDescendants(): any[];
        /**
         * Overridable function to return CSS class name to display icon
         * 
         * @param item             
         * @param opened             
         */
        getIconClass(item: dojo.data.api.Item, opened: boolean): String;
        /**
         * Overridable function to return CSS styles to display icon
         * 
         * @param item             
         * @param opened             
         */
        getIconStyle(item: dojo.data.api.Item, opened: boolean): Object;
        /**
         * Deprecated.   This should be specified on the model itself.
         * 
         * Overridable function that return array of child items of given parent item,
         * or if parentItem==null then return top items in tree
         * 
         * @param parentItem             
         * @param onComplete             
         */
        getItemChildren(parentItem: any, onComplete: any): void;
        /**
         * Overridable function to get the label for a tree node (given the item)
         * 
         * @param item             
         */
        getLabel(item: dojo.data.api.Item): any;
        /**
         * Overridable function to return CSS class name to display label
         * 
         * @param item             
         * @param opened             
         */
        getLabelClass(item: dojo.data.api.Item, opened: boolean): String;
        /**
         * Overridable function to return CSS styles to display label
         * 
         * @param item             
         * @param opened             
         */
        getLabelStyle(item: dojo.data.api.Item, opened: boolean): any;
        /**
         * Returns all tree nodes that refer to an item
         * 
         * @param item             
         */
        getNodesByItem(item: any): any;
        /**
         * Returns all tree nodes that refer to an item
         * 
         * @param item             
         */
        getNodesByItem(item: number): any;
        /**
         * Returns the parent widget of this widget.
         * 
         */
        getParent(): any;
        /**
         * Overridable function to return CSS class name to display row
         * 
         * @param item             
         * @param opened             
         */
        getRowClass(item: dojo.data.api.Item, opened: boolean): String;
        /**
         * Overridable function to return CSS styles to display row
         * 
         * @param item             
         * @param opened             
         */
        getRowStyle(item: dojo.data.api.Item, opened: boolean): any;
        /**
         * Overridable function to get the tooltip for a tree node (given the item)
         * 
         * @param item             
         */
        getTooltip(item: dojo.data.api.Item): String;
        /**
         * check whether a dom node is the expandoNode for a particular TreeNode widget
         * 
         * @param node             
         * @param widget             
         */
        isExpandoNode(node: any, widget: any): any;
        /**
         * Return true if this widget can currently be focused
         * and false if not
         * 
         */
        isFocusable(): any;
        /**
         * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
         * 
         */
        isLeftToRight(): any;
        /**
         * Returns objects passed to Tree.model.newItem() based on DnD nodes
         * dropped onto the tree.   Developer must override this method to enable
         * dropping from external sources onto this Tree, unless the Tree.model's items
         * happen to look like {id: 123, name: "Apple" } with no other attributes.
         * 
         * For each node in nodes[], which came from source, create a hash of name/value
         * pairs to be passed to Tree.model.newItem().  Returns array of those hashes.
         * 
         * @param nodes The DOMNodes dragged from the source container             
         * @param target The target TreeNode.rowNode             
         * @param source The source container the nodes were dragged from, perhaps another Tree or a plain dojo/dnd/Source             
         */
        itemCreator(nodes: HTMLElement[], target: HTMLElement, source: dojo.dnd.Source): any;
        /**
         * Deprecated.   This should be specified on the model itself.
         * 
         * Overridable function to tell if an item has or may have children.
         * Controls whether or not +/- expando icon is shown.
         * (For efficiency reasons we may not want to check if an element actually
         * has children until user clicks the expando node)
         * 
         * @param item             
         */
        mayHaveChildren(item: dojo.data.api.Item): void;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: String, func: Function): any;
        /**
         * 
         * @param type protected             
         * @param func             
         */
        on(type: Function, func: Function): any;
        /**
         * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
         * already removed/destroyed manually.
         * 
         */
        own(): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: String): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: String, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: HTMLElement, position: number): any;
        /**
         * Place this widget somewhere in the DOM based
         * on standard domConstruct.place() conventions.
         * A convenience function provided in all _Widgets, providing a simple
         * shorthand mechanism to put an existing (or newly created) Widget
         * somewhere in the dom, and allow chaining.
         * 
         * @param reference Widget, DOMNode, or id of widget or DOMNode             
         * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
         */
        placeAt(reference: dijit._WidgetBase, position: number): any;
        /**
         * 
         */
        postCreate(): void;
        /**
         * 
         */
        postMixInProperties(): void;
        /**
         * 
         * @param changeSize             
         */
        resize(changeSize: any): void;
        /**
         * Set a property on a widget
         * Sets named properties on a widget which may potentially be handled by a
         * setter in the widget.
         * 
         * For example, if the widget has properties foo and bar
         * and a method named _setFooAttr(), calling
         * myWidget.set("foo", "Howdy!") would be equivalent to calling
         * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
         * would be equivalent to the statement widget.bar = 3;
         * 
         * set() may also be called with a hash of name/value pairs, ex:
         * 
         * myWidget.set({
         *     foo: "Howdy",
         *     bar: 3
         * });
         * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
         * 
         * @param name The property to set.             
         * @param value The value to set in the property.             
         */
        set(name: any, value: any): any;
        /**
         * Deprecated.  Use set() instead.
         * 
         * @param attr             
         * @param value             
         */
        setAttribute(attr: String, value: any): void;
        /**
         * Processing after the DOM fragment is added to the document
         * Called after a widget and its children have been created and added to the page,
         * and all related widgets have finished their create() cycle, up through postCreate().
         * 
         * Note that startup() may be called while the widget is still hidden, for example if the widget is
         * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
         * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
         * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
         * 
         */
        startup(): void;
        /**
         * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
         * 
         * Subscribes to the specified topic and calls the specified method
         * of this object and registers for unsubscribe() on widget destroy.
         * 
         * Provide widget-specific analog to dojo.subscribe, except with the
         * implicit use of this widget as the target object.
         * 
         * @param t The topic             
         * @param method The callback             
         */
        subscribe(t: String, method: Function): any;
        /**
         * Returns a string that represents the widget.
         * When a widget is cast to a string, this method will be used to generate the
         * output. Currently, it does not implement any sort of reversible
         * serialization.
         * 
         */
        toString(): string;
        /**
         * Deprecated. Override destroy() instead to implement custom widget tear-down
         * behavior.
         * 
         */
        uninitialize(): boolean;
        /**
         * Deprecated, will be removed in 2.0, use handle.remove() instead.
         * 
         * Unsubscribes handle created by this.subscribe.
         * Also removes handle from this widget's list of subscriptions
         * 
         * @param handle             
         */
        unsubscribe(handle: Object): void;
        /**
         * Watches a property for changes
         * 
         * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
         * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
         */
        watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
        /**
         * Static method to get a template based on the templatePath or
         * templateString key
         */
        getCachedTemplate(): any;
        /**
         * Called when the widget stops being "active" because
         * focus moved to something outside of it, or the user
         * clicked somewhere outside of it, or the widget was
         * hidden.
         * 
         */
        onBlur(): void;
        /**
         * Callback when a tree node is clicked
         * 
         * @param item Object from the dojo/store corresponding to this TreeNode             
         * @param node The TreeNode itself             
         * @param evt The event             
         */
        onClick(item: any, node?: Object, evt?: Event): void;
        /**
         * Callback when a node is closed
         * 
         * @param item Object from the dojo/store corresponding to this TreeNode             
         * @param node The TreeNode itself             
         */
        onClose(item?: Object, node?: Object): boolean;
        /**
         * Callback when a tree node is double-clicked
         * 
         * @param item Object from the dojo/store corresponding to this TreeNode             
         * @param node The TreeNode itself             
         * @param evt The event             
         */
        onDblClick(item: any, node?: Object, evt?: Event): void;
        /**
         * Called when the widget becomes "active" because
         * it or a widget inside of it either has focus, or has recently
         * been clicked.
         * 
         */
        onFocus(): void;
        /**
         * Called when another widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onHide(): void;
        /**
         * When a key is pressed that matches a child item,
         * this method is called so that a widget can take appropriate action is necessary.
         * 
         * @param item             
         * @param evt             
         * @param searchString             
         * @param numMatches             
         */
        onKeyboardSearch(item: dijit._WidgetBase, evt: Event, searchString: String, numMatches: number): void;
        /**
         * Connect to this function to receive notifications of keys being pressed down.
         * 
         * @param event key Event             
         */
        onKeyDown(event: any): void;
        /**
         * Connect to this function to receive notifications of printable keys being typed.
         * 
         * @param event key Event             
         */
        onKeyPress(event: any): void;
        /**
         * Connect to this function to receive notifications of keys being released.
         * 
         * @param event key Event             
         */
        onKeyUp(event: any): void;
        /**
         * Called when tree finishes loading and expanding.
         * If persist == true the loading may encompass many levels of fetches
         * from the data store, each asynchronous.   Waits for all to finish.
         * 
         */
        onLoad(): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is pressed down.
         * 
         * @param event mouse Event             
         */
        onMouseDown(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto this widget.
         * 
         * @param event mouse Event             
         */
        onMouseEnter(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of this widget.
         * 
         * @param event mouse Event             
         */
        onMouseLeave(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseMove(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOut(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
         * 
         * @param event mouse Event             
         */
        onMouseOver(event: any): void;
        /**
         * Connect to this function to receive notifications of when the mouse button is released.
         * 
         * @param event mouse Event             
         */
        onMouseUp(event: any): void;
        /**
         * Callback when a node is opened
         * 
         * @param item             
         * @param node An object with the following properties:item (Item): the dojo.data entry this tree representsisTreeNode (Boolean): Indicates that this is a TreeNode.   Used by dijit.Tree only,should not be accessed directly.label (String): Text of this tree node_setLabelAttrlabelType (String): Specifies how to interpret the label.  Can be "html" or "text".isExpandable (Boolean): This node has children, so show the expando node (+ sign)isExpanded (Boolean): This node is currently expanded (ie, opened)state (String): Dynamic loading-related stuff.When an empty folder node appears, it is "NotLoaded" first,then after dojo.data query it becomes "Loading" and, finally "Loaded"templateStringbaseClasscssStateNodes_setTooltipAttrbuildRendering_setIndentAttr: Tell this node how many levels it should be indentedmarkProcessing: Visually denote that tree is loading data, etc.unmarkProcessing: Clear markup from markProcessing() call_updateItemClasses: Set appropriate CSS classes for icon and label dom node(used to allow for item updates to change respective CSS)_applyClassAndStyle: Set the appropriate CSS classes and styles for labels, icons and rows._updateLayout: Set appropriate CSS classes for this.domNode_setExpando: Set the right image for the expando nodeexpand: Show my childrencollapse: Collapse this node (if it's expanded)indent (Integer): Levels from this node to the root nodesetChildItems: Sets the child items of this node, removing/adding nodesfrom current children to match specified items[] array.Also, if this.persist == true, expands any children that were previouslyopened.getTreePathgetIdentityremoveChildmakeExpandable: if this node wasn't already showing the expando node,turn it into one and call _setExpando()setSelected: A Tree has a (single) currently selected node.Mark that this node is/isn't that currently selected node.focusonClick: Connect to this function to receive notifications of mouse click events.onDblClick: Connect to this function to receive notifications of mouse double click events.onKeyDown: Connect to this function to receive notifications of keys being pressed down.onKeyPress: Connect to this function to receive notifications of printable keys being typed.onKeyUp: Connect to this function to receive notifications of keys being released.onMouseDown: Connect to this function to receive notifications of when the mouse button is pressed down.onMouseMove: Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.onMouseOut: Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.onMouseOver: Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.onMouseLeave: Connect to this function to receive notifications of when the mouse moves off of this widget.onMouseEnter: Connect to this function to receive notifications of when the mouse moves onto this widget.onMouseUp: Connect to this function to receive notifications of when the mouse button is released.postCreateon_setFocusedAttrsetAttribute: Deprecated.  Use set() instead.attr: This method is deprecated, use get() or set() directly.getDescendants: Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.This method should generally be avoided as it returns widgets declared in templates, which aresupposed to be internal/hidden, but it's left here for back-compat reasons._onShow: Internal method called when this widget is made visible.See onShow for details.onShow: Called when this widget becomes the selected pane in adijit/layout/TabContainer, dijit/layout/StackContainer,dijit/layout/AccordionContainer, etc.Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.onHide: Called when another widget becomes the selected pane in adijit/layout/TabContainer, dijit/layout/StackContainer,dijit/layout/AccordionContainer, etc.Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.onClose: Called when this widget is being displayed as a popup (ex: a Calendar poppedup from a DateTextBox), and it is hidden.This is called from the dijit.popup code, and should not be called directly.Also used as a parameter for children of dijit/layout/StackContainer or subclasses.Callback if a user tries to close the child.   Child will be closed if this function returns true.id (String): A unique, opaque ID string that can be assigned by users or by thesystem. If the developer passes an ID which is known not to beunique, the specified ID is ignored and the system-generated ID isused instead._setIdAttrlang (String): Rarely used.  Overrides the default Dojo locale used to render this widget,as defined by the HTML LANG attribute.Value must be among the list of locales specified during by the Dojo bootstrap,formatted according to RFC 3066 (like en-us)._setLangAttrdir (String): Bi-directional support, as defined by the HTML DIRattribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page'sdefault direction._setDirAttrclass_setClassAttrstyle (String||Object): HTML style attributes as cssText string or name/value hashtitle (String): HTML title attribute.For form widgets this specifies a tooltip to display when hovering overthe widget (just like the native HTML title attribute).For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,etc., it's used to specify the tab label, accordion pane title, etc.  In this case it'sinterpreted as HTML.tooltip (String): When this widget's title attribute is used to for a tab label, accordion pane title, etc.,this specifies the tooltip to appear when the mouse is hovered over that text.srcNodeRef (DomNode): pointer to original DOM nodedomNode (DomNode): This is our visible representation of the widget! Other DOMNodes may by assigned to other properties, usually through thetemplate system's data-dojo-attach-point syntax, but the domNodeproperty is the canonical "top level" node in widget UI.containerNode (DomNode): Designates where children of the source DOM node will be placed."Children" in this case refers to both DOM nodes and widgets.For example, for myWidget:<div data-dojo-type=myWidget>    <b> here's a plain DOM node    <span data-dojo-type=subWidget>and a widget</span>    <i> and another plain DOM node </i></div>containerNode would point to:<b> here's a plain DOM node<span data-dojo-type=subWidget>and a widget</span><i> and another plain DOM node </i>In templated widgets, "containerNode" is set via adata-dojo-attach-point assignment.containerNode must be defined for any widget that accepts innerHTML(like ContentPane or BorderContainer or even Button), and converselyis null for widgets that don't, like TextBox.ownerDocument (Document?, optional): The document this widget belongs to.  If not specified to constructor, will default tosrcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global_setOwnerDocumentAttr_started (Boolean): startup() has completed.attributeMap (Object): Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attributefor each XXX attribute to be mapped to the DOM.attributeMap sets up a "binding" between attributes (aka properties)of the widget and the widget's DOM.Changes to widget attributes listed in attributeMap will bereflected into the DOM.For example, calling set('title', 'hello')on a TitlePane will automatically cause the TitlePane's DOM to updatewith the new title.attributeMap is a hash where the key is an attribute of the widget,and the value reflects a binding to a:DOM node attribute  focus: {node: "focusNode", type: "attribute"}Maps this.focus to this.focusNode.focusDOM node innerHTML  title: { node: "titleNode", type: "innerHTML" }Maps this.title to this.titleNode.innerHTMLDOM node innerText  title: { node: "titleNode", type: "innerText" }Maps this.title to this.titleNode.innerTextDOM node CSS class  myClass: { node: "domNode", type: "class" }Maps this.myClass to this.domNode.classNameIf the value is an array, then each element in the array matches one of theformats of the above list.There are also some shorthands for backwards compatibility:string --> { node: string, type: "attribute" }, for example:"focusNode" ---> { node: "focusNode", type: "attribute" }"" --> { node: "domNode", type: "attribute" }_blankGif (String): Path to a blank 1x1 image.Used by <img> nodes in templates that really get their image via CSS background-image._introspect: Collect metadata about this widget (only once per class, not once per instance):- list of attributes with custom setters, storing in this.constructor._setterAttrs- generate this.constructor._onMap, mapping names like "mousedown" to functions like onMouseDownpostscript: Kicks off widget instantiation.  See create() for details.create: Kick off the life-cycle of a widget_applyAttributes: Step during widget creation to copy  widget attributes to theDOM according to attributeMap and _setXXXAttr objects, and also to callcustom _setXXXAttr() methods.Skips over blank/false attribute values, unless they were explicitly specifiedas parameters to the widget, since those are the default anyway,and setting tabIndex="" is different than not setting tabIndex at all.For backwards-compatibility reasons attributeMap overrides _setXXXAttr when_setXXXAttr is a hash/string/array, but _setXXXAttr as a functions override attributeMap.postMixInProperties: Called after the parameters to the widget have been read-in,but before the widget template is instantiated. Especiallyuseful to set properties that are referenced in the widgettemplate.startup: Processing after the DOM fragment is added to the documentdestroyRecursive: Destroy this widget and its descendantsdestroy: Destroy this widget, but not its descendants.  Descendants means widgets inside ofthis.containerNode.   Will also destroy any resources (including widgets) registered via this.own().This method will also destroy internal widgets such as those created from a template,assuming those widgets exist inside of this.domNode but outside of this.containerNode.For 2.0 it's planned that this method will also destroy descendant widgets, so apps should notdepend on the current ability to destroy a widget without destroying its descendants.   Generallythey should use destroyRecursive() for widgets with children.destroyRendering: Destroys the DOM nodes associated with this widget.destroyDescendants: Recursively destroy the children of this widget and theirdescendants.uninitialize: Deprecated. Override destroy() instead to implement custom widget tear-downbehavior._setStyleAttr: Sets the style attribute of the widget according to value,which is either a hash like {height: "5px", width: "3px"}or a plain string_attrToDom: Reflect a widget attribute (title, tabIndex, duration etc.) tothe widget DOM, as specified by commands parameter.If commands isn't specified then it's looked up from attributeMap.Note some attributes like "type"cannot be processed this way as they are not mutable.get: Get a property from a widget.set: Set a property on a widget_attrPairNames_getAttrNames: Helper function for get() and set().Caches attribute name values so we don't do the string ops every time._set: Helper function to set new value for specified property, and call handlersregistered with watch() if the value has changed._get: Helper function to get value for specified property stored by this._set(),i.e. for properties with custom setters.  Used mainly by custom getters.For example, CheckBox._getValueAttr() calls this._get("value").emit: Used by widgets to signal that a synthetic event occurred, ex:myWidget.emit("attrmodified-selectedChildWidget", {}).Emits an event on this.domNode named type.toLowerCase(), based on eventObj.Also calls onType() method, if present, and returns value from that method.By default passes eventObj to callback, but will pass callbackArgs instead, if specified.Modifies eventObj by adding missing parameters (bubbles, cancelable, widget)._onMap: Maps on() type parameter (ex: "mousemove") to method name (ex: "onMouseMove").If type is a synthetic event like touch.press then returns undefined.toString: Returns a string that represents the widget.getChildren: Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parentis this widget.   Note that it does not return all descendants, but rather just direct children.Analogous to Node.childNodes,except containing widgets rather than DOMNodes.The result intentionally excludes internally created widgets (a.k.a. supporting widgets)outside of this.containerNode.Note that the array returned is a simple array.  Application code should not assumeexistence of methods like forEach().getParent: Returns the parent widget of this widget.connect: Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.Connects specified obj/event to specified method of this objectand registers for disconnect() on widget destroy.Provide widget-specific analog to dojo.connect, except with theimplicit use of this widget as the target object.Events connected with this.connect are disconnected upondestruction.disconnect: Deprecated, will be removed in 2.0, use handle.remove() instead.Disconnects handle created by connect.subscribe: Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.Subscribes to the specified topic and calls the specified methodof this object and registers for unsubscribe() on widget destroy.Provide widget-specific analog to dojo.subscribe, except with theimplicit use of this widget as the target object.unsubscribe: Deprecated, will be removed in 2.0, use handle.remove() instead.Unsubscribes handle created by this.subscribe.Also removes handle from this widget's list of subscriptionsisLeftToRight: Return this widget's explicit or implicit orientation (true for LTR, false for RTL)isFocusable: Return true if this widget can currently be focusedand false if notplaceAt: Place this widget somewhere in the DOM basedon standard domConstruct.place() conventions.defer: Wrapper to setTimeout to avoid deferred functions executingafter the originating widget has been destroyed.Returns an object handle with a remove method (that returns null) (replaces clearTimeout)._changeAttrValue: Internal helper for directly changing an attribute value.watch: Watches a property for changesown: Track specified handles and remove/destroy them when this instance is destroyed, unless they werealready removed/destroyed manually.focused (Boolean): This widget or a widget it contains has focus, or is "active" becauseit was recently clicked.onFocus: Called when the widget becomes "active" becauseit or a widget inside of it either has focus, or has recentlybeen clicked.onBlur: Called when the widget stops being "active" becausefocus moved to something outside of it, or the userclicked somewhere outside of it, or the widget washidden._onFocus: This is where widgets do processing for when they are active,such as changing CSS classes.  See onFocus() for more details._onBlur: This is where widgets do processing for when they stop being active,such as changing CSS classes.  See onBlur() for more details._focusManagertemplatePath (String): Path to template (HTML file) for this widget relative to dojo.baseUrl.Deprecated: use templateString with require([... "dojo/text!..."], ...) instead_skipNodeCache_rendered (Boolean): Not normally use, but this flag can be set by the app if the server has already rendered the template,i.e. already inlining the template for the widget into the main page.   Reduces _TemplatedMixin tojust function like _AttachMixin.searchContainerNode_stringRepl: Does substitution of ${foo} type properties in template string_fillContent: Relocate source contents to templated container node.this.containerNode must be able to receive children, or exceptions will be thrown._attachPoints (String[]): List of widget attribute names associated with data-dojo-attach-point=... in thetemplate, ex: ["containerNode", "labelNode"]_attachEvents (Handle[]): List of connections associated with data-dojo-attach-event=... in thetemplateattachScope (Object): Object to which attach points and events will be scoped.  Defaultsto 'this'._beforeFillContent_attachTemplateNodes: Iterate through the dom nodes and attach functions and nodes accordingly._processTemplateNode: Process data-dojo-attach-point and data-dojo-attach-event for given node or widget.Returns true if caller should process baseNode's children too._attach: Roughly corresponding to dojo/on, this is the default function for processing adata-dojo-attach-event.  Meant to attach to DOMNodes, not to widgets._detachTemplateNodes: Detach and clean up the attachments made in _attachtempalteNodes.addChild: Makes the given widget a child of this widget.hasChildren: Returns true if widget has child widgets, i.e. if this.containerNode contains widgets._getSiblingOfChild: Get the next or previous widget sibling of childgetIndexOfChild: Gets the index of the child in this container or -1 if not found_getSibling: Returns next or previous siblinggetPreviousSibling: Returns null if this is the first child of the parent,otherwise returns the next element sibling to the "left".getNextSibling: Returns null if this is the last child of the parent,otherwise returns the next element sibling to the "right".getIndexInParent: Returns the index of this widget within its container parent.It returns -1 if the parent does not exist, or if the parentis not a dijit/_Containerhovering (Boolean): True if cursor is over this widgetactive (Boolean): True if mouse was pressed while over this widget, and hasn't been released yet_cssMouseEvent: Handler for CSS event on this.domNode. Sets hovering and active properties depending on mouse state,which triggers _setStateClass() to set appropriate CSS classes for this.domNode._setStateClass: Update the visual state of the widget by setting the css classes on this.domNode(or this.stateNode if defined) by combining this.baseClass withvarious suffixes that represent the current widget state(s)._subnodeCssMouseEvent: Handler for hover/active mouse event on widget's subnode_trackMouseState: Track mouse/focus events on specified node and set CSS class on that node to indicatecurrent state.   Usually not called directly, but via cssStateNodes attribute.            
         */
        onOpen(item: dojo.data.api.Item, node: Object): void;
        /**
         * Called when this widget becomes the selected pane in a
         * dijit/layout/TabContainer, dijit/layout/StackContainer,
         * dijit/layout/AccordionContainer, etc.
         * 
         * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
         * 
         */
        onShow(): void;
    }
    module Tree {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/Tree._TreeNode.html
         *
         * Single node within a tree.   This class is used internally
         * by Tree and should not be accessed directly.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _TreeNode extends dijit._Widget implements dijit._TemplatedMixin, dijit._Container, dijit._Contained, dijit._CssStateMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Levels from this node to the root node
             * 
             */
            "indent": number;
            set(property:"indent", value: number): void;
            get(property:"indent"): number;
            watch(property:"indent", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * This node is currently expanded (ie, opened)
             * 
             */
            "isExpanded": boolean;
            set(property:"isExpanded", value: boolean): void;
            get(property:"isExpanded"): boolean;
            watch(property:"isExpanded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Indicates that this is a TreeNode.   Used by dijit.Tree only,
             * should not be accessed directly.
             * 
             */
            "isTreeNode": boolean;
            set(property:"isTreeNode", value: boolean): void;
            get(property:"isTreeNode"): boolean;
            watch(property:"isTreeNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * the dojo.data entry this tree represents
             * 
             */
            "item": Object;
            set(property:"item", value: Object): void;
            get(property:"item"): Object;
            watch(property:"item", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Text of this tree node
             * 
             */
            "label": string;
            set(property:"label", value: string): void;
            get(property:"label"): string;
            watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Specifies how to interpret the label.  Can be "html" or "text".
             * 
             */
            "labelType": string;
            set(property:"labelType", value: string): void;
            get(property:"labelType"): string;
            watch(property:"labelType", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Collapse this node (if it's expanded)
             * 
             */
            collapse(): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Show my children
             * 
             */
            expand(): any;
            /**
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * 
             */
            getIdentity(): any;
            /**
             * Returns the index of this widget within its container parent.
             * It returns -1 if the parent does not exist, or if the parent
             * is not a dijit/_Container
             * 
             */
            getIndexInParent(): any;
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns null if this is the last child of the parent,
             * otherwise returns the next element sibling to the "right".
             * 
             */
            getNextSibling(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns null if this is the first child of the parent,
             * otherwise returns the next element sibling to the "left".
             * 
             */
            getPreviousSibling(): any;
            /**
             * 
             */
            getTreePath(): any[];
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * if this node wasn't already showing the expando node,
             * turn it into one and call _setExpando()
             * 
             */
            makeExpandable(): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(node: dijit.Tree._TreeNode): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Sets the child items of this node, removing/adding nodes
             * from current children to match specified items[] array.
             * Also, if this.persist == true, expands any children that were previously
             * opened.
             * 
             * @param items             
             */
            setChildItems(items: Object[]): any;
            /**
             * A Tree has a (single) currently selected node.
             * Mark that this node is/isn't that currently selected node.
             * In particular, setting a node as selected involves setting tabIndex
             * so that when user tabs to the tree, focus will go to that node (only).
             * 
             * @param selected             
             */
            setSelected(selected: boolean): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
    }

    module _editor {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/_Plugin.html
         *
         * Base class for a "plugin" to the editor, which is usually
         * a single button on the Toolbar and some associated code
         * 
         * @param args       OptionalInitial settings for any of the attributes.     
         */
        class _Plugin extends dijit.Destroyable {
            constructor(args?: Object);
            /**
             * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
             * that is added to the toolbar to control this plugin.
             * If not specified, will be created on initialization according to buttonClass
             * 
             */
            "button": Object;
            /**
             * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
             * Passed to editor.execCommand() if useDefaultCommand is true.
             * 
             */
            "command": string;
            /**
             * Flag to indicate if this plugin has been disabled and should do nothing
             * helps control button state, among other things.  Set via the setter api.
             * 
             */
            "disabled": boolean;
            /**
             * Points to the parent editor
             * 
             */
            "editor": Object;
            /**
             * The CSS class name for the button node is formed from iconClassPrefix and command
             * 
             */
            "iconClassPrefix": string;
            /**
             * 
             */
            "registry": Object;
            /**
             * If true, this plugin executes by calling Editor.execCommand() with the argument specified in command.
             * 
             */
            "useDefaultCommand": boolean;
            /**
             * Class of widget (ex: dijit.form.Button or dijit/form/FilteringSelect)
             * that is added to the toolbar to control this plugin.
             * This is used to instantiate the button, unless button itself is specified directly.
             * 
             */
            buttonClass(): void;
            /**
             * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
             * 
             * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
             * Similar to dijit/_Widget.connect().
             * 
             * @param o             
             * @param f             
             * @param tf             
             */
            connect(o: any, f: any, tf: any): void;
            /**
             * 
             */
            destroy(): void;
            /**
             * Get a property from a plugin.
             * Get a named property from a plugin. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * For example, if the plugin has a properties "foo"
             * and "bar" and a method named "_getFooAttr", calling:
             * 
             * plugin.get("foo");
             * would be equivalent to writing:
             * 
             * plugin._getFooAttr();
             * and:
             * 
             * plugin.get("bar");
             * would be equivalent to writing:
             * 
             * plugin.bar;
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Set a property on a plugin
             * Sets named properties on a plugin which may potentially be handled by a
             * setter in the plugin.
             * For example, if the plugin has a properties "foo"
             * and "bar" and a method named "_setFooAttr", calling:
             * 
             * plugin.set("foo", "Howdy!");
             * would be equivalent to writing:
             * 
             * plugin._setFooAttr("Howdy!");
             * and:
             * 
             * plugin.set("bar", 3);
             * would be equivalent to writing:
             * 
             * plugin.bar = 3;
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * plugin.set({
             *     foo: "Howdy",
             *     bar: 3
             * })
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: Attr, value: any): any;
            /**
             * Tell the plugin which Editor it is associated with.
             * 
             * @param editor             
             */
            setEditor(editor: dijit.Editor): void;
            /**
             * Tell the plugin to add it's controller widget (often a button)
             * to the toolbar.  Does nothing if there is no controller widget.
             * 
             * @param toolbar             
             */
            setToolbar(toolbar: dijit.Toolbar): void;
            /**
             * Change state of the plugin to respond to events in the editor.
             * This is called on meaningful events in the editor, such as change of selection
             * or caret position (but not simple typing of alphanumeric keys).   It gives the
             * plugin a chance to update the CSS of its button.
             * 
             * For example, the "bold" plugin will highlight/unhighlight the bold button depending on whether the
             * characters next to the caret are bold or not.
             * 
             * Only makes sense when useDefaultCommand is true, as it calls Editor.queryCommandEnabled(command).
             * 
             */
            updateState(): void;
        }
        module _Plugin {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/_Plugin.registry.html
             *
             * 
             */
            interface registry {
                /**
                 * 
                 * @param args             
                 */
                bold(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                colorTableCell(args: any): void;
                /**
                 * 
                 * @param args             
                 */
                copy(args: any): any;
                /**
                 * 
                 */
                createLink(): void;
                /**
                 * 
                 * @param args             
                 */
                cut(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                delete(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                deleteTableColumn(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                deleteTableRow(args: any): any;
                /**
                 * 
                 */
                foreColor(): void;
                /**
                 * 
                 * @param args             
                 */
                fullScreen(args: any): void;
                /**
                 * 
                 * @param args             
                 */
                fullscreen(args: any): void;
                /**
                 * 
                 */
                hiliteColor(): void;
                /**
                 * 
                 * @param args             
                 */
                indent(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                insertHorizontalRule(args: any): any;
                /**
                 * 
                 */
                insertImage(): void;
                /**
                 * 
                 * @param args             
                 */
                insertOrderedList(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                insertTable(args: any): void;
                /**
                 * 
                 * @param args             
                 */
                insertTableColumnAfter(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                insertTableColumnBefore(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                insertTableRowAfter(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                insertTableRowBefore(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                insertUnorderedList(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                italic(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                justifyCenter(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                justifyFull(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                justifyLeft(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                justifyRight(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                LocalImage(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                localImage(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                localimage(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                modifyTable(args: any): void;
                /**
                 * 
                 * @param args             
                 */
                newPage(args: any): void;
                /**
                 * 
                 * @param args             
                 */
                newpage(args: any): void;
                /**
                 * 
                 * @param args             
                 */
                outdent(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                paste(args: any): any;
                /**
                 * 
                 */
                print(): void;
                /**
                 * 
                 * @param args             
                 */
                redo(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                removeFormat(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                selectAll(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                strikethrough(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                subscript(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                superscript(args: any): any;
                /**
                 * 
                 */
                tabIndent(): void;
                /**
                 * 
                 * @param args             
                 */
                tableContextMenu(args: any): void;
                /**
                 * 
                 */
                toggleDir(): void;
                /**
                 * 
                 * @param args             
                 */
                underline(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                undo(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                unlink(args: any): any;
                /**
                 * 
                 * @param args             
                 */
                viewSource(args: any): void;
                /**
                 * 
                 * @param args             
                 */
                viewsource(args: any): void;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/RichText.html
         *
         * dijit/_editor/RichText is the core of dijit.Editor, which provides basic
         * WYSIWYG editing features.
         * dijit/_editor/RichText is the core of dijit.Editor, which provides basic
         * WYSIWYG editing features. It also encapsulates the differences
         * of different js engines for various browsers.  Do not use this widget
         * with an HTML <TEXTAREA> tag, since the browser unescapes XML escape characters,
         * like <.  This can have unexpected behavior and lead to security issues
         * such as scripting attacks.
         * 
         * @param params Initial settings for any of the widget attributes, except readonly attributes.     
         * @param srcNodeRef The widget replaces the specified DOMNode.     
         */
        class RichText extends dijit._Widget implements dijit._CssStateMixin {
            constructor(params: Object, srcNodeRef: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Events which should be connected to the underlying editing
             * area, events in this array will be addListener with
             * capture=true.
             * 
             */
            "captureEvents": Object;
            set(property:"captureEvents", value: Object): void;
            get(property:"captureEvents"): Object;
            watch(property:"captureEvents", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The editor is disabled; the text cannot be changed.
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * When true, disables the browser's native spell checking, if supported.
             * Works only in Firefox.
             * 
             */
            "disableSpellCheck": boolean;
            set(property:"disableSpellCheck", value: boolean): void;
            get(property:"disableSpellCheck"): boolean;
            watch(property:"disableSpellCheck", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Focus into this widget when the page is loaded
             * 
             */
            "focusOnLoad": boolean;
            set(property:"focusOnLoad", value: boolean): void;
            get(property:"focusOnLoad"): boolean;
            watch(property:"focusOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set height to fix the editor at a specific height, with scrolling.
             * By default, this is 300px.  If you want to have the editor always
             * resizes to accommodate the content, use AlwaysShowToolbar plugin
             * and set height="".  If this editor is used within a layout widget,
             * set height="100%".
             * 
             */
            "height": string;
            set(property:"height", value: string): void;
            get(property:"height"): string;
            watch(property:"height", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * whether to inherit the parent's width or simply use 100%
             * 
             */
            "inheritWidth": boolean;
            set(property:"inheritWidth", value: boolean): void;
            get(property:"inheritWidth"): boolean;
            watch(property:"inheritWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "isClosed": boolean;
            set(property:"isClosed", value: boolean): void;
            get(property:"isClosed"): boolean;
            watch(property:"isClosed", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "isLoaded": boolean;
            set(property:"isLoaded", value: boolean): void;
            get(property:"isLoaded"): boolean;
            watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Make tab key and shift-tab indent and outdent rather than navigating.
             * Caution: sing this makes web pages inaccessible to users unable to use a mouse.
             * 
             */
            "isTabIndent": boolean;
            set(property:"isTabIndent", value: boolean): void;
            get(property:"isTabIndent"): boolean;
            watch(property:"isTabIndent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The minimum height that the editor should have.
             * 
             */
            "minHeight": string;
            set(property:"minHeight", value: string): void;
            get(property:"minHeight"): string;
            watch(property:"minHeight", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Specifies the name of a (hidden) <textarea> node on the page that's used to save
             * the editor content on page leave.   Used to restore editor contents after navigating
             * to a new page and then hitting the back button.
             * 
             */
            "name": Object;
            set(property:"name", value: Object): void;
            get(property:"name"): Object;
            watch(property:"name", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deferred which is fired when the editor finishes loading.
             * Call myEditor.onLoadDeferred.then(callback) it to be informed
             * when the rich-text area initialization is finalized.
             * 
             */
            "onLoadDeferred": Object;
            set(property:"onLoadDeferred", value: Object): void;
            get(property:"onLoadDeferred"): Object;
            watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * semicolon (";") separated list of css files for the editing area
             * 
             */
            "styleSheets": string;
            set(property:"styleSheets", value: string): void;
            get(property:"styleSheets"): string;
            watch(property:"styleSheets", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "updateInterval": number;
            set(property:"updateInterval", value: number): void;
            get(property:"updateInterval"): number;
            watch(property:"updateInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Add a handler for a keyboard shortcut
             * 
             * @param key             
             * @param ctrl             
             * @param shift             
             * @param handler             
             */
            addKeyHandler(key: String, ctrl: boolean, shift: boolean, handler: Function): void;
            /**
             * Add a handler for a keyboard shortcut
             * 
             * @param key             
             * @param ctrl             
             * @param shift             
             * @param handler             
             */
            addKeyHandler(key: number, ctrl: boolean, shift: boolean, handler: Function): void;
            /**
             * add an external stylesheet for the editing area
             * 
             * @param uri Url of the external css file             
             */
            addStyleSheet(uri: dojo._base.url): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Remove focus from this instance.
             * 
             */
            blur(): void;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Executes a command in the Rich Text area
             * 
             * @param command The command to execute             
             * @param argument An optional argument to the command             
             */
            execCommand(command: String, argument: any): any;
            /**
             * Move focus to this editor
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * A function for obtaining the height of the footer node
             * 
             */
            getFooterHeight(): any;
            /**
             * A function for obtaining the height of the header node
             * 
             */
            getHeaderHeight(): any;
            /**
             * Deprecated.   Use dijit/_editor/html::getChildrenHtml() instead.
             * 
             * @param dom             
             */
            getNodeChildrenHtml(dom: HTMLElement): any;
            /**
             * Deprecated.   Use dijit/_editor/html::_getNodeHtml() instead.
             * 
             * @param node             
             */
            getNodeHtml(node: HTMLElement): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Check whether a command is enabled or not.
             * 
             * @param command The command to execute             
             */
            queryCommandEnabled(command: String): any;
            /**
             * Check the state of a given command and returns true or false.
             * 
             * @param command             
             */
            queryCommandState(command: any): any;
            /**
             * Check the value of a given command. This matters most for
             * custom selections and complex values like font value setting.
             * 
             * @param command             
             */
            queryCommandValue(command: any): any;
            /**
             * remove an external stylesheet for the editing area
             * 
             * @param uri             
             */
            removeStyleSheet(uri: dojo._base.url): void;
            /**
             * This function set the content while trying to maintain the undo stack
             * (now only works fine with Moz, this is identical to setValue in all
             * other browsers)
             * 
             * @param html             
             */
            replaceValue(html: String): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated, use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Add some default key handlers
             * Overwrite this to setup your own handlers. The default
             * implementation does not use Editor commands, but directly
             * executes the builtin commands within the underlying browser
             * support.
             * 
             */
            setupDefaultShortcuts(): void;
            /**
             * This function sets the content. No undo history is preserved.
             * Users should use set('value', ...) instead.
             * 
             * @param html             
             */
            setValue(html: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * This is fired if and only if the editor loses focus and
             * the content is changed.
             * 
             * @param newContent             
             */
            onChange(newContent: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Handler for keydown event
             * 
             * @param e             
             */
            onKeyDown(e: Event): boolean;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Handler for onkeyup event
             * 
             * @param e             
             */
            onKeyUp(e: any): void;
            /**
             * Handler after the iframe finishes loading.
             * 
             * @param html Editor contents should be set to this value             
             */
            onLoad(html: String): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module plugins {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/AlwaysShowToolbar.html
             *
             * This plugin is required for Editors in auto-expand mode.
             * It handles the auto-expansion as the user adds/deletes text,
             * and keeps the editor's toolbar visible even when the top of the editor
             * has scrolled off the top of the viewport (usually when editing a long
             * document).
             * Specify this in extraPlugins (or plugins) parameter and also set
             * height to "".
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class AlwaysShowToolbar extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                 * Passed to editor.execCommand() if useDefaultCommand is true.
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * If true, this plugin executes by calling Editor.execCommand() with the argument specified in command.
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * Class of widget (ex: dijit.form.Button or dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * This is used to instantiate the button, unless button itself is specified directly.
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * 
                 * @param e             
                 */
                setEditor(e: any): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Change state of the plugin to respond to events in the editor.
                 * This is called on meaningful events in the editor, such as change of selection
                 * or caret position (but not simple typing of alphanumeric keys).   It gives the
                 * plugin a chance to update the CSS of its button.
                 * 
                 * For example, the "bold" plugin will highlight/unhighlight the bold button depending on whether the
                 * characters next to the caret are bold or not.
                 * 
                 * Only makes sense when useDefaultCommand is true, as it calls Editor.queryCommandEnabled(command).
                 * 
                 */
                updateState(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/FontChoice.html
             *
             * This plugin provides three drop downs for setting style in the editor
             * (font, font size, and format block), as controlled by command.
             * The commands provided by this plugin are:
             * 
             * fontName: Provides a drop down to select from a list of font names
             * fontSize: Provides a drop down to select from a list of font sizes
             * formatBlock: Provides a drop down to select from a list of block styles
             * which can easily be added to an editor by including one or more of the above commands
             * in the plugins attribute as follows:
             * plugins="['fontName','fontSize',...]"
             * It is possible to override the default dropdown list by providing an Array for the custom property when
             * instantiating this plugin, e.g.
             * 
             * plugins="[{name:'dijit._editor.plugins.FontChoice', command:'fontName', values:['Verdana','Myriad','Garamond']},...]"
             * Alternatively, for fontName only, generic:true may be specified to provide a dropdown with
             * CSS generic font families.
             * 
             * Note that the editor is often unable to properly handle font styling information defined outside
             * the context of the current editor instance, such as pre-populated HTML.
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class FontChoice extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                 * Passed to editor.execCommand() if useDefaultCommand is true.
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * Override _Plugin.useDefaultCommand...
                 * processing is handled by this plugin, not by dijit/Editor.
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * Class of widget (ex: dijit.form.Button or dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * This is used to instantiate the button, unless button itself is specified directly.
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * Tell the plugin which Editor it is associated with.
                 * 
                 * @param editor             
                 */
                setEditor(editor: dijit.Editor): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Overrides _Plugin.updateState().  This controls updating the menu
                 * options to the right values on state changes in the document (that trigger a
                 * test of the actions.)
                 * It set value of drop down in toolbar to reflect font/font size/format block
                 * of text at current caret position.
                 * 
                 */
                updateState(): void;
            }
            module FontChoice {
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/FontChoice._FontDropDown.html
                 *
                 * Base class for widgets that contains a label (like "Font:")
                 * and a FilteringSelect drop down to pick a value.
                 * Used as Toolbar entry.
                 * 
                 * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
                 * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
                 */
                class _FontDropDown extends dijit._Widget implements dijit._TemplatedMixin, dijit._WidgetsInTemplateMixin {
                    constructor(params?: Object, srcNodeRef?: HTMLElement);
                    /**
                     * Object to which attach points and events will be scoped.  Defaults
                     * to 'this'.
                     * 
                     */
                    "attachScope": Object;
                    set(property:"attachScope", value: Object): void;
                    get(property:"attachScope"): Object;
                    watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                     * for each XXX attribute to be mapped to the DOM.
                     * 
                     * attributeMap sets up a "binding" between attributes (aka properties)
                     * of the widget and the widget's DOM.
                     * Changes to widget attributes listed in attributeMap will be
                     * reflected into the DOM.
                     * 
                     * For example, calling set('title', 'hello')
                     * on a TitlePane will automatically cause the TitlePane's DOM to update
                     * with the new title.
                     * 
                     * attributeMap is a hash where the key is an attribute of the widget,
                     * and the value reflects a binding to a:
                     * 
                     * DOM node attribute
                     *   focus: {node: "focusNode", type: "attribute"}
                     * Maps this.focus to this.focusNode.focus
                     * 
                     * DOM node innerHTML
                     *   title: { node: "titleNode", type: "innerHTML" }
                     * Maps this.title to this.titleNode.innerHTML
                     * 
                     * DOM node innerText
                     *   title: { node: "titleNode", type: "innerText" }
                     * Maps this.title to this.titleNode.innerText
                     * 
                     * DOM node CSS class
                     *   myClass: { node: "domNode", type: "class" }
                     * Maps this.myClass to this.domNode.className
                     * 
                     * If the value is an array, then each element in the array matches one of the
                     * formats of the above list.
                     * 
                     * There are also some shorthands for backwards compatibility:
                     * 
                     * string --> { node: string, type: "attribute" }, for example:
                     * "focusNode" ---> { node: "focusNode", type: "attribute" }
                     * "" --> { node: "domNode", type: "attribute" }
                     * 
                     */
                    "attributeMap": Object;
                    set(property:"attributeMap", value: Object): void;
                    get(property:"attributeMap"): Object;
                    watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
                     * widget state.
                     * 
                     */
                    "baseClass": string;
                    set(property:"baseClass", value: string): void;
                    get(property:"baseClass"): string;
                    watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "class": string;
                    set(property:"class", value: string): void;
                    get(property:"class"): string;
                    watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Designates where children of the source DOM node will be placed.
                     * "Children" in this case refers to both DOM nodes and widgets.
                     * For example, for myWidget:
                     * 
                     * <div data-dojo-type=myWidget>
                     *     <b> here's a plain DOM node
                     *     <span data-dojo-type=subWidget>and a widget</span>
                     *     <i> and another plain DOM node </i>
                     * </div>
                     * containerNode would point to:
                     * 
                     * <b> here's a plain DOM node
                     * <span data-dojo-type=subWidget>and a widget</span>
                     * <i> and another plain DOM node </i>
                     * In templated widgets, "containerNode" is set via a
                     * data-dojo-attach-point assignment.
                     * 
                     * containerNode must be defined for any widget that accepts innerHTML
                     * (like ContentPane or BorderContainer or even Button), and conversely
                     * is null for widgets that don't, like TextBox.
                     * 
                     */
                    "containerNode": HTMLElement;
                    set(property:"containerNode", value: HTMLElement): void;
                    get(property:"containerNode"): HTMLElement;
                    watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * Bi-directional support, as defined by the HTML DIR
                     * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                     * default direction.
                     * 
                     */
                    "dir": string;
                    set(property:"dir", value: string): void;
                    get(property:"dir"): string;
                    watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * This is our visible representation of the widget! Other DOM
                     * Nodes may by assigned to other properties, usually through the
                     * template system's data-dojo-attach-point syntax, but the domNode
                     * property is the canonical "top level" node in widget UI.
                     * 
                     */
                    "domNode": HTMLElement;
                    set(property:"domNode", value: HTMLElement): void;
                    get(property:"domNode"): HTMLElement;
                    watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * This widget or a widget it contains has focus, or is "active" because
                     * it was recently clicked.
                     * 
                     */
                    "focused": boolean;
                    set(property:"focused", value: boolean): void;
                    get(property:"focused"): boolean;
                    watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * A unique, opaque ID string that can be assigned by users or by the
                     * system. If the developer passes an ID which is known not to be
                     * unique, the specified ID is ignored and the system-generated ID is
                     * used instead.
                     * 
                     */
                    "id": string;
                    set(property:"id", value: string): void;
                    get(property:"id"): string;
                    watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The label to apply to this particular FontDropDown.
                     * 
                     */
                    "label": string;
                    set(property:"label", value: string): void;
                    get(property:"label"): string;
                    watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Rarely used.  Overrides the default Dojo locale used to render this widget,
                     * as defined by the HTML LANG attribute.
                     * Value must be among the list of locales specified during by the Dojo bootstrap,
                     * formatted according to RFC 3066 (like en-us).
                     * 
                     */
                    "lang": string;
                    set(property:"lang", value: string): void;
                    get(property:"lang"): string;
                    watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The document this widget belongs to.  If not specified to constructor, will default to
                     * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                     * 
                     */
                    "ownerDocument": Object;
                    set(property:"ownerDocument", value: Object): void;
                    get(property:"ownerDocument"): Object;
                    watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Flag to indicate that the returned label should be plain text
                     * instead of an example.
                     * 
                     */
                    "plainText": boolean;
                    set(property:"plainText", value: boolean): void;
                    get(property:"plainText"): boolean;
                    watch(property:"plainText", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "searchContainerNode": boolean;
                    set(property:"searchContainerNode", value: boolean): void;
                    get(property:"searchContainerNode"): boolean;
                    watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * pointer to original DOM node
                     * 
                     */
                    "srcNodeRef": HTMLElement;
                    set(property:"srcNodeRef", value: HTMLElement): void;
                    get(property:"srcNodeRef"): HTMLElement;
                    watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * HTML style attributes as cssText string or name/value hash
                     * 
                     */
                    "style": string;
                    set(property:"style", value: string): void;
                    get(property:"style"): string;
                    watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                     * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                     * 
                     */
                    "templatePath": string;
                    set(property:"templatePath", value: string): void;
                    get(property:"templatePath"): string;
                    watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The template used to construct the labeled dropdown.
                     * 
                     */
                    "templateString": string;
                    set(property:"templateString", value: string): void;
                    get(property:"templateString"): string;
                    watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * HTML title attribute.
                     * 
                     * For form widgets this specifies a tooltip to display when hovering over
                     * the widget (just like the native HTML title attribute).
                     * 
                     * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                     * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                     * interpreted as HTML.
                     * 
                     */
                    "title": string;
                    set(property:"title", value: string): void;
                    get(property:"title"): string;
                    watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                     * this specifies the tooltip to appear when the mouse is hovered over that text.
                     * 
                     */
                    "tooltip": string;
                    set(property:"tooltip", value: string): void;
                    get(property:"tooltip"): string;
                    watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Should we parse the template to find widgets that might be
                     * declared in markup inside it?  (Remove for 2.0 and assume true)
                     * 
                     */
                    "widgetsInTemplate": boolean;
                    set(property:"widgetsInTemplate", value: boolean): void;
                    get(property:"widgetsInTemplate"): boolean;
                    watch(property:"widgetsInTemplate", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * This method is deprecated, use get() or set() directly.
                     * 
                     * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                     * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                     */
                    attr(name: String, value: Object): any;
                    /**
                     * This method is deprecated, use get() or set() directly.
                     * 
                     * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                     * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                     */
                    attr(name: Object, value: Object): any;
                    /**
                     * Construct the UI for this widget, setting this.domNode.
                     * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
                     * 
                     */
                    buildRendering(): void;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: String, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: String, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: Function, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: Function, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: String, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: String, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: Function, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: Function, method: Function): any;
                    /**
                     * The context require that is used to resolve modules in template.
                     * 
                     */
                    contextRequire(): void;
                    /**
                     * Wrapper to setTimeout to avoid deferred functions executing
                     * after the originating widget has been destroyed.
                     * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                     * 
                     * @param fcn Function reference.             
                     * @param delay               OptionalDelay, defaults to 0.             
                     */
                    defer(fcn: Function, delay: number): Object;
                    /**
                     * Destroy this widget, but not its descendants.  Descendants means widgets inside of
                     * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
                     * 
                     * This method will also destroy internal widgets such as those created from a template,
                     * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
                     * 
                     * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
                     * depend on the current ability to destroy a widget without destroying its descendants.   Generally
                     * they should use destroyRecursive() for widgets with children.
                     * 
                     * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
                     */
                    destroy(preserveDom?: boolean): void;
                    /**
                     * Recursively destroy the children of this widget and their
                     * descendants.
                     * 
                     * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                     */
                    destroyDescendants(preserveDom?: boolean): void;
                    /**
                     * Destroy this widget and its descendants
                     * This is the generic "destructor" function that all widget users
                     * should call to cleanly discard with a widget. Once a widget is
                     * destroyed, it is removed from the manager object.
                     * 
                     * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                     */
                    destroyRecursive(preserveDom?: boolean): void;
                    /**
                     * Destroys the DOM nodes associated with this widget.
                     * 
                     * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                     */
                    destroyRendering(preserveDom?: boolean): void;
                    /**
                     * Deprecated, will be removed in 2.0, use handle.remove() instead.
                     * 
                     * Disconnects handle created by connect.
                     * 
                     * @param handle             
                     */
                    disconnect(handle: any): void;
                    /**
                     * Used by widgets to signal that a synthetic event occurred, ex:
                     * 
                     * myWidget.emit("attrmodified-selectedChildWidget", {}).
                     * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                     * Also calls onType() method, if present, and returns value from that method.
                     * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                     * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                     * 
                     * @param type             
                     * @param eventObj               Optional            
                     * @param callbackArgs               Optional            
                     */
                    emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                    /**
                     * Over-ride for focus control of this widget.  Delegates focus down to the
                     * filtering select.
                     * 
                     */
                    focus(): void;
                    /**
                     * Get a property from a widget.
                     * Get a named property from a widget. The property may
                     * potentially be retrieved via a getter method. If no getter is defined, this
                     * just retrieves the object's property.
                     * 
                     * For example, if the widget has properties foo and bar
                     * and a method named _getFooAttr(), calling:
                     * myWidget.get("foo") would be equivalent to calling
                     * widget._getFooAttr() and myWidget.get("bar")
                     * would be equivalent to the expression
                     * widget.bar2
                     * 
                     * @param name The property to get.             
                     */
                    get(name: any): any;
                    /**
                     * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                     * is this widget.   Note that it does not return all descendants, but rather just direct children.
                     * Analogous to Node.childNodes,
                     * except containing widgets rather than DOMNodes.
                     * 
                     * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                     * outside of this.containerNode.
                     * 
                     * Note that the array returned is a simple array.  Application code should not assume
                     * existence of methods like forEach().
                     * 
                     */
                    getChildren(): any[];
                    /**
                     * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                     * This method should generally be avoided as it returns widgets declared in templates, which are
                     * supposed to be internal/hidden, but it's left here for back-compat reasons.
                     * 
                     */
                    getDescendants(): any[];
                    /**
                     * Returns the parent widget of this widget.
                     * 
                     */
                    getParent(): any;
                    /**
                     * Return true if this widget can currently be focused
                     * and false if not
                     * 
                     */
                    isFocusable(): any;
                    /**
                     * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                     * 
                     */
                    isLeftToRight(): any;
                    /**
                     * 
                     * @param type protected             
                     * @param func             
                     */
                    on(type: String, func: Function): any;
                    /**
                     * 
                     * @param type protected             
                     * @param func             
                     */
                    on(type: Function, func: Function): any;
                    /**
                     * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                     * already removed/destroyed manually.
                     * 
                     */
                    own(): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: String, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: HTMLElement, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: dijit._WidgetBase, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: String, position: number): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: HTMLElement, position: number): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: dijit._WidgetBase, position: number): any;
                    /**
                     * Over-ride for the default postCreate action
                     * This establishes the filtering selects and the like.
                     * 
                     */
                    postCreate(): void;
                    /**
                     * Over-ride to set specific properties.
                     * 
                     */
                    postMixInProperties(): void;
                    /**
                     * Set a property on a widget
                     * Sets named properties on a widget which may potentially be handled by a
                     * setter in the widget.
                     * 
                     * For example, if the widget has properties foo and bar
                     * and a method named _setFooAttr(), calling
                     * myWidget.set("foo", "Howdy!") would be equivalent to calling
                     * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                     * would be equivalent to the statement widget.bar = 3;
                     * 
                     * set() may also be called with a hash of name/value pairs, ex:
                     * 
                     * myWidget.set({
                     *     foo: "Howdy",
                     *     bar: 3
                     * });
                     * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                     * 
                     * @param name The property to set.             
                     * @param value The value to set in the property.             
                     */
                    set(name: any, value: any): any;
                    /**
                     * Deprecated.  Use set() instead.
                     * 
                     * @param attr             
                     * @param value             
                     */
                    setAttribute(attr: String, value: any): void;
                    /**
                     * Processing after the DOM fragment is added to the document
                     * Called after a widget and its children have been created and added to the page,
                     * and all related widgets have finished their create() cycle, up through postCreate().
                     * 
                     * Note that startup() may be called while the widget is still hidden, for example if the widget is
                     * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
                     * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
                     * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
                     * 
                     */
                    startup(): void;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                     * 
                     * Subscribes to the specified topic and calls the specified method
                     * of this object and registers for unsubscribe() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.subscribe, except with the
                     * implicit use of this widget as the target object.
                     * 
                     * @param t The topic             
                     * @param method The callback             
                     */
                    subscribe(t: String, method: Function): any;
                    /**
                     * Returns a string that represents the widget.
                     * When a widget is cast to a string, this method will be used to generate the
                     * output. Currently, it does not implement any sort of reversible
                     * serialization.
                     * 
                     */
                    toString(): string;
                    /**
                     * Deprecated. Override destroy() instead to implement custom widget tear-down
                     * behavior.
                     * 
                     */
                    uninitialize(): boolean;
                    /**
                     * Deprecated, will be removed in 2.0, use handle.remove() instead.
                     * 
                     * Unsubscribes handle created by this.subscribe.
                     * Also removes handle from this widget's list of subscriptions
                     * 
                     * @param handle             
                     */
                    unsubscribe(handle: Object): void;
                    /**
                     * Watches a property for changes
                     * 
                     * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                     * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                     */
                    watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                    /**
                     * Static method to get a template based on the templatePath or
                     * templateString key
                     */
                    getCachedTemplate(): any;
                    /**
                     * Called when the widget stops being "active" because
                     * focus moved to something outside of it, or the user
                     * clicked somewhere outside of it, or the widget was
                     * hidden.
                     * 
                     */
                    onBlur(): void;
                    /**
                     * Connect to this function to receive notifications of mouse click events.
                     * 
                     * @param event mouse Event             
                     */
                    onClick(event: any): void;
                    /**
                     * Called when this widget is being displayed as a popup (ex: a Calendar popped
                     * up from a DateTextBox), and it is hidden.
                     * This is called from the dijit.popup code, and should not be called directly.
                     * 
                     * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                     * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                     * 
                     */
                    onClose(): boolean;
                    /**
                     * Connect to this function to receive notifications of mouse double click events.
                     * 
                     * @param event mouse Event             
                     */
                    onDblClick(event: any): void;
                    /**
                     * Called when the widget becomes "active" because
                     * it or a widget inside of it either has focus, or has recently
                     * been clicked.
                     * 
                     */
                    onFocus(): void;
                    /**
                     * Called when another widget becomes the selected pane in a
                     * dijit/layout/TabContainer, dijit/layout/StackContainer,
                     * dijit/layout/AccordionContainer, etc.
                     * 
                     * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                     * 
                     */
                    onHide(): void;
                    /**
                     * Connect to this function to receive notifications of keys being pressed down.
                     * 
                     * @param event key Event             
                     */
                    onKeyDown(event: any): void;
                    /**
                     * Connect to this function to receive notifications of printable keys being typed.
                     * 
                     * @param event key Event             
                     */
                    onKeyPress(event: any): void;
                    /**
                     * Connect to this function to receive notifications of keys being released.
                     * 
                     * @param event key Event             
                     */
                    onKeyUp(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse button is pressed down.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseDown(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves onto this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseEnter(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves off of this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseLeave(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseMove(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseOut(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseOver(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse button is released.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseUp(event: any): void;
                    /**
                     * Called when this widget becomes the selected pane in a
                     * dijit/layout/TabContainer, dijit/layout/StackContainer,
                     * dijit/layout/AccordionContainer, etc.
                     * 
                     * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                     * 
                     */
                    onShow(): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/FontChoice._FontNameDropDown.html
                 *
                 * Dropdown to select a font; goes in editor toolbar.
                 * 
                 * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
                 * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
                 */
                class _FontNameDropDown extends dijit._Widget implements dijit._TemplatedMixin, dijit._WidgetsInTemplateMixin {
                    constructor(params?: Object, srcNodeRef?: HTMLElement);
                    /**
                     * Object to which attach points and events will be scoped.  Defaults
                     * to 'this'.
                     * 
                     */
                    "attachScope": Object;
                    set(property:"attachScope", value: Object): void;
                    get(property:"attachScope"): Object;
                    watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                     * for each XXX attribute to be mapped to the DOM.
                     * 
                     * attributeMap sets up a "binding" between attributes (aka properties)
                     * of the widget and the widget's DOM.
                     * Changes to widget attributes listed in attributeMap will be
                     * reflected into the DOM.
                     * 
                     * For example, calling set('title', 'hello')
                     * on a TitlePane will automatically cause the TitlePane's DOM to update
                     * with the new title.
                     * 
                     * attributeMap is a hash where the key is an attribute of the widget,
                     * and the value reflects a binding to a:
                     * 
                     * DOM node attribute
                     *   focus: {node: "focusNode", type: "attribute"}
                     * Maps this.focus to this.focusNode.focus
                     * 
                     * DOM node innerHTML
                     *   title: { node: "titleNode", type: "innerHTML" }
                     * Maps this.title to this.titleNode.innerHTML
                     * 
                     * DOM node innerText
                     *   title: { node: "titleNode", type: "innerText" }
                     * Maps this.title to this.titleNode.innerText
                     * 
                     * DOM node CSS class
                     *   myClass: { node: "domNode", type: "class" }
                     * Maps this.myClass to this.domNode.className
                     * 
                     * If the value is an array, then each element in the array matches one of the
                     * formats of the above list.
                     * 
                     * There are also some shorthands for backwards compatibility:
                     * 
                     * string --> { node: string, type: "attribute" }, for example:
                     * "focusNode" ---> { node: "focusNode", type: "attribute" }
                     * "" --> { node: "domNode", type: "attribute" }
                     * 
                     */
                    "attributeMap": Object;
                    set(property:"attributeMap", value: Object): void;
                    get(property:"attributeMap"): Object;
                    watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
                     * widget state.
                     * 
                     */
                    "baseClass": string;
                    set(property:"baseClass", value: string): void;
                    get(property:"baseClass"): string;
                    watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "class": string;
                    set(property:"class", value: string): void;
                    get(property:"class"): string;
                    watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "comboClass": string;
                    set(property:"comboClass", value: string): void;
                    get(property:"comboClass"): string;
                    watch(property:"comboClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The editor 'command' implemented by this plugin.
                     * 
                     */
                    "command": string;
                    set(property:"command", value: string): void;
                    get(property:"command"): string;
                    watch(property:"command", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Designates where children of the source DOM node will be placed.
                     * "Children" in this case refers to both DOM nodes and widgets.
                     * For example, for myWidget:
                     * 
                     * <div data-dojo-type=myWidget>
                     *     <b> here's a plain DOM node
                     *     <span data-dojo-type=subWidget>and a widget</span>
                     *     <i> and another plain DOM node </i>
                     * </div>
                     * containerNode would point to:
                     * 
                     * <b> here's a plain DOM node
                     * <span data-dojo-type=subWidget>and a widget</span>
                     * <i> and another plain DOM node </i>
                     * In templated widgets, "containerNode" is set via a
                     * data-dojo-attach-point assignment.
                     * 
                     * containerNode must be defined for any widget that accepts innerHTML
                     * (like ContentPane or BorderContainer or even Button), and conversely
                     * is null for widgets that don't, like TextBox.
                     * 
                     */
                    "containerNode": HTMLElement;
                    set(property:"containerNode", value: HTMLElement): void;
                    get(property:"containerNode"): HTMLElement;
                    watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * Bi-directional support, as defined by the HTML DIR
                     * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                     * default direction.
                     * 
                     */
                    "dir": string;
                    set(property:"dir", value: string): void;
                    get(property:"dir"): string;
                    watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * This is our visible representation of the widget! Other DOM
                     * Nodes may by assigned to other properties, usually through the
                     * template system's data-dojo-attach-point syntax, but the domNode
                     * property is the canonical "top level" node in widget UI.
                     * 
                     */
                    "domNode": HTMLElement;
                    set(property:"domNode", value: HTMLElement): void;
                    get(property:"domNode"): HTMLElement;
                    watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * This widget or a widget it contains has focus, or is "active" because
                     * it was recently clicked.
                     * 
                     */
                    "focused": boolean;
                    set(property:"focused", value: boolean): void;
                    get(property:"focused"): boolean;
                    watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * Use generic (web standard) font names
                     * 
                     */
                    "generic": boolean;
                    set(property:"generic", value: boolean): void;
                    get(property:"generic"): boolean;
                    watch(property:"generic", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * A unique, opaque ID string that can be assigned by users or by the
                     * system. If the developer passes an ID which is known not to be
                     * unique, the specified ID is ignored and the system-generated ID is
                     * used instead.
                     * 
                     */
                    "id": string;
                    set(property:"id", value: string): void;
                    get(property:"id"): string;
                    watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The label to apply to this particular FontDropDown.
                     * 
                     */
                    "label": string;
                    set(property:"label", value: string): void;
                    get(property:"label"): string;
                    watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Rarely used.  Overrides the default Dojo locale used to render this widget,
                     * as defined by the HTML LANG attribute.
                     * Value must be among the list of locales specified during by the Dojo bootstrap,
                     * formatted according to RFC 3066 (like en-us).
                     * 
                     */
                    "lang": string;
                    set(property:"lang", value: string): void;
                    get(property:"lang"): string;
                    watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The document this widget belongs to.  If not specified to constructor, will default to
                     * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                     * 
                     */
                    "ownerDocument": Object;
                    set(property:"ownerDocument", value: Object): void;
                    get(property:"ownerDocument"): Object;
                    watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Flag to indicate that the returned label should be plain text
                     * instead of an example.
                     * 
                     */
                    "plainText": boolean;
                    set(property:"plainText", value: boolean): void;
                    get(property:"plainText"): boolean;
                    watch(property:"plainText", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "searchContainerNode": boolean;
                    set(property:"searchContainerNode", value: boolean): void;
                    get(property:"searchContainerNode"): boolean;
                    watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * pointer to original DOM node
                     * 
                     */
                    "srcNodeRef": HTMLElement;
                    set(property:"srcNodeRef", value: HTMLElement): void;
                    get(property:"srcNodeRef"): HTMLElement;
                    watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * HTML style attributes as cssText string or name/value hash
                     * 
                     */
                    "style": string;
                    set(property:"style", value: string): void;
                    get(property:"style"): string;
                    watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                     * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                     * 
                     */
                    "templatePath": string;
                    set(property:"templatePath", value: string): void;
                    get(property:"templatePath"): string;
                    watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The template used to construct the labeled dropdown.
                     * 
                     */
                    "templateString": string;
                    set(property:"templateString", value: string): void;
                    get(property:"templateString"): string;
                    watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * HTML title attribute.
                     * 
                     * For form widgets this specifies a tooltip to display when hovering over
                     * the widget (just like the native HTML title attribute).
                     * 
                     * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                     * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                     * interpreted as HTML.
                     * 
                     */
                    "title": string;
                    set(property:"title", value: string): void;
                    get(property:"title"): string;
                    watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                     * this specifies the tooltip to appear when the mouse is hovered over that text.
                     * 
                     */
                    "tooltip": string;
                    set(property:"tooltip", value: string): void;
                    get(property:"tooltip"): string;
                    watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Should we parse the template to find widgets that might be
                     * declared in markup inside it?  (Remove for 2.0 and assume true)
                     * 
                     */
                    "widgetsInTemplate": boolean;
                    set(property:"widgetsInTemplate", value: boolean): void;
                    get(property:"widgetsInTemplate"): boolean;
                    watch(property:"widgetsInTemplate", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * This method is deprecated, use get() or set() directly.
                     * 
                     * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                     * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                     */
                    attr(name: String, value: Object): any;
                    /**
                     * This method is deprecated, use get() or set() directly.
                     * 
                     * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                     * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                     */
                    attr(name: Object, value: Object): any;
                    /**
                     * Construct the UI for this widget, setting this.domNode.
                     * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
                     * 
                     */
                    buildRendering(): void;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: String, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: String, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: Function, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: Function, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: String, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: String, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: Function, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: Function, method: Function): any;
                    /**
                     * The context require that is used to resolve modules in template.
                     * 
                     */
                    contextRequire(): void;
                    /**
                     * Wrapper to setTimeout to avoid deferred functions executing
                     * after the originating widget has been destroyed.
                     * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                     * 
                     * @param fcn Function reference.             
                     * @param delay               OptionalDelay, defaults to 0.             
                     */
                    defer(fcn: Function, delay: number): Object;
                    /**
                     * Destroy this widget, but not its descendants.  Descendants means widgets inside of
                     * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
                     * 
                     * This method will also destroy internal widgets such as those created from a template,
                     * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
                     * 
                     * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
                     * depend on the current ability to destroy a widget without destroying its descendants.   Generally
                     * they should use destroyRecursive() for widgets with children.
                     * 
                     * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
                     */
                    destroy(preserveDom?: boolean): void;
                    /**
                     * Recursively destroy the children of this widget and their
                     * descendants.
                     * 
                     * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                     */
                    destroyDescendants(preserveDom?: boolean): void;
                    /**
                     * Destroy this widget and its descendants
                     * This is the generic "destructor" function that all widget users
                     * should call to cleanly discard with a widget. Once a widget is
                     * destroyed, it is removed from the manager object.
                     * 
                     * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                     */
                    destroyRecursive(preserveDom?: boolean): void;
                    /**
                     * Destroys the DOM nodes associated with this widget.
                     * 
                     * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                     */
                    destroyRendering(preserveDom?: boolean): void;
                    /**
                     * Deprecated, will be removed in 2.0, use handle.remove() instead.
                     * 
                     * Disconnects handle created by connect.
                     * 
                     * @param handle             
                     */
                    disconnect(handle: any): void;
                    /**
                     * Used by widgets to signal that a synthetic event occurred, ex:
                     * 
                     * myWidget.emit("attrmodified-selectedChildWidget", {}).
                     * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                     * Also calls onType() method, if present, and returns value from that method.
                     * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                     * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                     * 
                     * @param type             
                     * @param eventObj               Optional            
                     * @param callbackArgs               Optional            
                     */
                    emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                    /**
                     * Over-ride for focus control of this widget.  Delegates focus down to the
                     * filtering select.
                     * 
                     */
                    focus(): void;
                    /**
                     * Get a property from a widget.
                     * Get a named property from a widget. The property may
                     * potentially be retrieved via a getter method. If no getter is defined, this
                     * just retrieves the object's property.
                     * 
                     * For example, if the widget has properties foo and bar
                     * and a method named _getFooAttr(), calling:
                     * myWidget.get("foo") would be equivalent to calling
                     * widget._getFooAttr() and myWidget.get("bar")
                     * would be equivalent to the expression
                     * widget.bar2
                     * 
                     * @param name The property to get.             
                     */
                    get(name: any): any;
                    /**
                     * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                     * is this widget.   Note that it does not return all descendants, but rather just direct children.
                     * Analogous to Node.childNodes,
                     * except containing widgets rather than DOMNodes.
                     * 
                     * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                     * outside of this.containerNode.
                     * 
                     * Note that the array returned is a simple array.  Application code should not assume
                     * existence of methods like forEach().
                     * 
                     */
                    getChildren(): any[];
                    /**
                     * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                     * This method should generally be avoided as it returns widgets declared in templates, which are
                     * supposed to be internal/hidden, but it's left here for back-compat reasons.
                     * 
                     */
                    getDescendants(): any[];
                    /**
                     * Function used to generate the labels of the format dropdown
                     * will return a formatted, or plain label based on the value
                     * of the plainText option.
                     * 
                     * @param value The 'insert value' associated with a name             
                     * @param name The text name of the value             
                     */
                    getLabel(value: String, name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     * 
                     */
                    getParent(): any;
                    /**
                     * Return true if this widget can currently be focused
                     * and false if not
                     * 
                     */
                    isFocusable(): any;
                    /**
                     * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                     * 
                     */
                    isLeftToRight(): any;
                    /**
                     * 
                     * @param type protected             
                     * @param func             
                     */
                    on(type: String, func: Function): any;
                    /**
                     * 
                     * @param type protected             
                     * @param func             
                     */
                    on(type: Function, func: Function): any;
                    /**
                     * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                     * already removed/destroyed manually.
                     * 
                     */
                    own(): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: String, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: HTMLElement, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: dijit._WidgetBase, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: String, position: number): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: HTMLElement, position: number): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: dijit._WidgetBase, position: number): any;
                    /**
                     * Over-ride for the default postCreate action
                     * This establishes the filtering selects and the like.
                     * 
                     */
                    postCreate(): void;
                    /**
                     * Over-ride for the default posr mixin control
                     * 
                     */
                    postMixInProperties(): void;
                    /**
                     * Set a property on a widget
                     * Sets named properties on a widget which may potentially be handled by a
                     * setter in the widget.
                     * 
                     * For example, if the widget has properties foo and bar
                     * and a method named _setFooAttr(), calling
                     * myWidget.set("foo", "Howdy!") would be equivalent to calling
                     * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                     * would be equivalent to the statement widget.bar = 3;
                     * 
                     * set() may also be called with a hash of name/value pairs, ex:
                     * 
                     * myWidget.set({
                     *     foo: "Howdy",
                     *     bar: 3
                     * });
                     * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                     * 
                     * @param name The property to set.             
                     * @param value The value to set in the property.             
                     */
                    set(name: any, value: any): any;
                    /**
                     * Deprecated.  Use set() instead.
                     * 
                     * @param attr             
                     * @param value             
                     */
                    setAttribute(attr: String, value: any): void;
                    /**
                     * Processing after the DOM fragment is added to the document
                     * Called after a widget and its children have been created and added to the page,
                     * and all related widgets have finished their create() cycle, up through postCreate().
                     * 
                     * Note that startup() may be called while the widget is still hidden, for example if the widget is
                     * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
                     * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
                     * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
                     * 
                     */
                    startup(): void;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                     * 
                     * Subscribes to the specified topic and calls the specified method
                     * of this object and registers for unsubscribe() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.subscribe, except with the
                     * implicit use of this widget as the target object.
                     * 
                     * @param t The topic             
                     * @param method The callback             
                     */
                    subscribe(t: String, method: Function): any;
                    /**
                     * Returns a string that represents the widget.
                     * When a widget is cast to a string, this method will be used to generate the
                     * output. Currently, it does not implement any sort of reversible
                     * serialization.
                     * 
                     */
                    toString(): string;
                    /**
                     * Deprecated. Override destroy() instead to implement custom widget tear-down
                     * behavior.
                     * 
                     */
                    uninitialize(): boolean;
                    /**
                     * Deprecated, will be removed in 2.0, use handle.remove() instead.
                     * 
                     * Unsubscribes handle created by this.subscribe.
                     * Also removes handle from this widget's list of subscriptions
                     * 
                     * @param handle             
                     */
                    unsubscribe(handle: Object): void;
                    /**
                     * Watches a property for changes
                     * 
                     * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                     * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                     */
                    watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                    /**
                     * Static method to get a template based on the templatePath or
                     * templateString key
                     */
                    getCachedTemplate(): any;
                    /**
                     * Called when the widget stops being "active" because
                     * focus moved to something outside of it, or the user
                     * clicked somewhere outside of it, or the widget was
                     * hidden.
                     * 
                     */
                    onBlur(): void;
                    /**
                     * Connect to this function to receive notifications of mouse click events.
                     * 
                     * @param event mouse Event             
                     */
                    onClick(event: any): void;
                    /**
                     * Called when this widget is being displayed as a popup (ex: a Calendar popped
                     * up from a DateTextBox), and it is hidden.
                     * This is called from the dijit.popup code, and should not be called directly.
                     * 
                     * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                     * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                     * 
                     */
                    onClose(): boolean;
                    /**
                     * Connect to this function to receive notifications of mouse double click events.
                     * 
                     * @param event mouse Event             
                     */
                    onDblClick(event: any): void;
                    /**
                     * Called when the widget becomes "active" because
                     * it or a widget inside of it either has focus, or has recently
                     * been clicked.
                     * 
                     */
                    onFocus(): void;
                    /**
                     * Called when another widget becomes the selected pane in a
                     * dijit/layout/TabContainer, dijit/layout/StackContainer,
                     * dijit/layout/AccordionContainer, etc.
                     * 
                     * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                     * 
                     */
                    onHide(): void;
                    /**
                     * Connect to this function to receive notifications of keys being pressed down.
                     * 
                     * @param event key Event             
                     */
                    onKeyDown(event: any): void;
                    /**
                     * Connect to this function to receive notifications of printable keys being typed.
                     * 
                     * @param event key Event             
                     */
                    onKeyPress(event: any): void;
                    /**
                     * Connect to this function to receive notifications of keys being released.
                     * 
                     * @param event key Event             
                     */
                    onKeyUp(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse button is pressed down.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseDown(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves onto this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseEnter(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves off of this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseLeave(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseMove(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseOut(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseOver(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse button is released.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseUp(event: any): void;
                    /**
                     * Called when this widget becomes the selected pane in a
                     * dijit/layout/TabContainer, dijit/layout/StackContainer,
                     * dijit/layout/AccordionContainer, etc.
                     * 
                     * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                     * 
                     */
                    onShow(): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/FontChoice._FontSizeDropDown.html
                 *
                 * Dropdown to select a font size; goes in editor toolbar.
                 * 
                 * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
                 * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
                 */
                class _FontSizeDropDown extends dijit._Widget implements dijit._TemplatedMixin, dijit._WidgetsInTemplateMixin {
                    constructor(params?: Object, srcNodeRef?: HTMLElement);
                    /**
                     * Object to which attach points and events will be scoped.  Defaults
                     * to 'this'.
                     * 
                     */
                    "attachScope": Object;
                    set(property:"attachScope", value: Object): void;
                    get(property:"attachScope"): Object;
                    watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                     * for each XXX attribute to be mapped to the DOM.
                     * 
                     * attributeMap sets up a "binding" between attributes (aka properties)
                     * of the widget and the widget's DOM.
                     * Changes to widget attributes listed in attributeMap will be
                     * reflected into the DOM.
                     * 
                     * For example, calling set('title', 'hello')
                     * on a TitlePane will automatically cause the TitlePane's DOM to update
                     * with the new title.
                     * 
                     * attributeMap is a hash where the key is an attribute of the widget,
                     * and the value reflects a binding to a:
                     * 
                     * DOM node attribute
                     *   focus: {node: "focusNode", type: "attribute"}
                     * Maps this.focus to this.focusNode.focus
                     * 
                     * DOM node innerHTML
                     *   title: { node: "titleNode", type: "innerHTML" }
                     * Maps this.title to this.titleNode.innerHTML
                     * 
                     * DOM node innerText
                     *   title: { node: "titleNode", type: "innerText" }
                     * Maps this.title to this.titleNode.innerText
                     * 
                     * DOM node CSS class
                     *   myClass: { node: "domNode", type: "class" }
                     * Maps this.myClass to this.domNode.className
                     * 
                     * If the value is an array, then each element in the array matches one of the
                     * formats of the above list.
                     * 
                     * There are also some shorthands for backwards compatibility:
                     * 
                     * string --> { node: string, type: "attribute" }, for example:
                     * "focusNode" ---> { node: "focusNode", type: "attribute" }
                     * "" --> { node: "domNode", type: "attribute" }
                     * 
                     */
                    "attributeMap": Object;
                    set(property:"attributeMap", value: Object): void;
                    get(property:"attributeMap"): Object;
                    watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
                     * widget state.
                     * 
                     */
                    "baseClass": string;
                    set(property:"baseClass", value: string): void;
                    get(property:"baseClass"): string;
                    watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "class": string;
                    set(property:"class", value: string): void;
                    get(property:"class"): string;
                    watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "comboClass": string;
                    set(property:"comboClass", value: string): void;
                    get(property:"comboClass"): string;
                    watch(property:"comboClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The editor 'command' implemented by this plugin.
                     * 
                     */
                    "command": string;
                    set(property:"command", value: string): void;
                    get(property:"command"): string;
                    watch(property:"command", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Designates where children of the source DOM node will be placed.
                     * "Children" in this case refers to both DOM nodes and widgets.
                     * For example, for myWidget:
                     * 
                     * <div data-dojo-type=myWidget>
                     *     <b> here's a plain DOM node
                     *     <span data-dojo-type=subWidget>and a widget</span>
                     *     <i> and another plain DOM node </i>
                     * </div>
                     * containerNode would point to:
                     * 
                     * <b> here's a plain DOM node
                     * <span data-dojo-type=subWidget>and a widget</span>
                     * <i> and another plain DOM node </i>
                     * In templated widgets, "containerNode" is set via a
                     * data-dojo-attach-point assignment.
                     * 
                     * containerNode must be defined for any widget that accepts innerHTML
                     * (like ContentPane or BorderContainer or even Button), and conversely
                     * is null for widgets that don't, like TextBox.
                     * 
                     */
                    "containerNode": HTMLElement;
                    set(property:"containerNode", value: HTMLElement): void;
                    get(property:"containerNode"): HTMLElement;
                    watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * Bi-directional support, as defined by the HTML DIR
                     * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                     * default direction.
                     * 
                     */
                    "dir": string;
                    set(property:"dir", value: string): void;
                    get(property:"dir"): string;
                    watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * This is our visible representation of the widget! Other DOM
                     * Nodes may by assigned to other properties, usually through the
                     * template system's data-dojo-attach-point syntax, but the domNode
                     * property is the canonical "top level" node in widget UI.
                     * 
                     */
                    "domNode": HTMLElement;
                    set(property:"domNode", value: HTMLElement): void;
                    get(property:"domNode"): HTMLElement;
                    watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * This widget or a widget it contains has focus, or is "active" because
                     * it was recently clicked.
                     * 
                     */
                    "focused": boolean;
                    set(property:"focused", value: boolean): void;
                    get(property:"focused"): boolean;
                    watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * A unique, opaque ID string that can be assigned by users or by the
                     * system. If the developer passes an ID which is known not to be
                     * unique, the specified ID is ignored and the system-generated ID is
                     * used instead.
                     * 
                     */
                    "id": string;
                    set(property:"id", value: string): void;
                    get(property:"id"): string;
                    watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The label to apply to this particular FontDropDown.
                     * 
                     */
                    "label": string;
                    set(property:"label", value: string): void;
                    get(property:"label"): string;
                    watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Rarely used.  Overrides the default Dojo locale used to render this widget,
                     * as defined by the HTML LANG attribute.
                     * Value must be among the list of locales specified during by the Dojo bootstrap,
                     * formatted according to RFC 3066 (like en-us).
                     * 
                     */
                    "lang": string;
                    set(property:"lang", value: string): void;
                    get(property:"lang"): string;
                    watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The document this widget belongs to.  If not specified to constructor, will default to
                     * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                     * 
                     */
                    "ownerDocument": Object;
                    set(property:"ownerDocument", value: Object): void;
                    get(property:"ownerDocument"): Object;
                    watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Flag to indicate that the returned label should be plain text
                     * instead of an example.
                     * 
                     */
                    "plainText": boolean;
                    set(property:"plainText", value: boolean): void;
                    get(property:"plainText"): boolean;
                    watch(property:"plainText", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "searchContainerNode": boolean;
                    set(property:"searchContainerNode", value: boolean): void;
                    get(property:"searchContainerNode"): boolean;
                    watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * pointer to original DOM node
                     * 
                     */
                    "srcNodeRef": HTMLElement;
                    set(property:"srcNodeRef", value: HTMLElement): void;
                    get(property:"srcNodeRef"): HTMLElement;
                    watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * HTML style attributes as cssText string or name/value hash
                     * 
                     */
                    "style": string;
                    set(property:"style", value: string): void;
                    get(property:"style"): string;
                    watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                     * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                     * 
                     */
                    "templatePath": string;
                    set(property:"templatePath", value: string): void;
                    get(property:"templatePath"): string;
                    watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The template used to construct the labeled dropdown.
                     * 
                     */
                    "templateString": string;
                    set(property:"templateString", value: string): void;
                    get(property:"templateString"): string;
                    watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * HTML title attribute.
                     * 
                     * For form widgets this specifies a tooltip to display when hovering over
                     * the widget (just like the native HTML title attribute).
                     * 
                     * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                     * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                     * interpreted as HTML.
                     * 
                     */
                    "title": string;
                    set(property:"title", value: string): void;
                    get(property:"title"): string;
                    watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                     * this specifies the tooltip to appear when the mouse is hovered over that text.
                     * 
                     */
                    "tooltip": string;
                    set(property:"tooltip", value: string): void;
                    get(property:"tooltip"): string;
                    watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The HTML font size values supported by this plugin
                     * 
                     */
                    "values": Object;
                    set(property:"values", value: Object): void;
                    get(property:"values"): Object;
                    watch(property:"values", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Should we parse the template to find widgets that might be
                     * declared in markup inside it?  (Remove for 2.0 and assume true)
                     * 
                     */
                    "widgetsInTemplate": boolean;
                    set(property:"widgetsInTemplate", value: boolean): void;
                    get(property:"widgetsInTemplate"): boolean;
                    watch(property:"widgetsInTemplate", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * This method is deprecated, use get() or set() directly.
                     * 
                     * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                     * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                     */
                    attr(name: String, value: Object): any;
                    /**
                     * This method is deprecated, use get() or set() directly.
                     * 
                     * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                     * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                     */
                    attr(name: Object, value: Object): any;
                    /**
                     * Construct the UI for this widget, setting this.domNode.
                     * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
                     * 
                     */
                    buildRendering(): void;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: String, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: String, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: Function, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: Function, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: String, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: String, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: Function, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: Function, method: Function): any;
                    /**
                     * The context require that is used to resolve modules in template.
                     * 
                     */
                    contextRequire(): void;
                    /**
                     * Wrapper to setTimeout to avoid deferred functions executing
                     * after the originating widget has been destroyed.
                     * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                     * 
                     * @param fcn Function reference.             
                     * @param delay               OptionalDelay, defaults to 0.             
                     */
                    defer(fcn: Function, delay: number): Object;
                    /**
                     * Destroy this widget, but not its descendants.  Descendants means widgets inside of
                     * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
                     * 
                     * This method will also destroy internal widgets such as those created from a template,
                     * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
                     * 
                     * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
                     * depend on the current ability to destroy a widget without destroying its descendants.   Generally
                     * they should use destroyRecursive() for widgets with children.
                     * 
                     * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
                     */
                    destroy(preserveDom?: boolean): void;
                    /**
                     * Recursively destroy the children of this widget and their
                     * descendants.
                     * 
                     * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                     */
                    destroyDescendants(preserveDom?: boolean): void;
                    /**
                     * Destroy this widget and its descendants
                     * This is the generic "destructor" function that all widget users
                     * should call to cleanly discard with a widget. Once a widget is
                     * destroyed, it is removed from the manager object.
                     * 
                     * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                     */
                    destroyRecursive(preserveDom?: boolean): void;
                    /**
                     * Destroys the DOM nodes associated with this widget.
                     * 
                     * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                     */
                    destroyRendering(preserveDom?: boolean): void;
                    /**
                     * Deprecated, will be removed in 2.0, use handle.remove() instead.
                     * 
                     * Disconnects handle created by connect.
                     * 
                     * @param handle             
                     */
                    disconnect(handle: any): void;
                    /**
                     * Used by widgets to signal that a synthetic event occurred, ex:
                     * 
                     * myWidget.emit("attrmodified-selectedChildWidget", {}).
                     * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                     * Also calls onType() method, if present, and returns value from that method.
                     * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                     * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                     * 
                     * @param type             
                     * @param eventObj               Optional            
                     * @param callbackArgs               Optional            
                     */
                    emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                    /**
                     * Over-ride for focus control of this widget.  Delegates focus down to the
                     * filtering select.
                     * 
                     */
                    focus(): void;
                    /**
                     * Get a property from a widget.
                     * Get a named property from a widget. The property may
                     * potentially be retrieved via a getter method. If no getter is defined, this
                     * just retrieves the object's property.
                     * 
                     * For example, if the widget has properties foo and bar
                     * and a method named _getFooAttr(), calling:
                     * myWidget.get("foo") would be equivalent to calling
                     * widget._getFooAttr() and myWidget.get("bar")
                     * would be equivalent to the expression
                     * widget.bar2
                     * 
                     * @param name The property to get.             
                     */
                    get(name: any): any;
                    /**
                     * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                     * is this widget.   Note that it does not return all descendants, but rather just direct children.
                     * Analogous to Node.childNodes,
                     * except containing widgets rather than DOMNodes.
                     * 
                     * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                     * outside of this.containerNode.
                     * 
                     * Note that the array returned is a simple array.  Application code should not assume
                     * existence of methods like forEach().
                     * 
                     */
                    getChildren(): any[];
                    /**
                     * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                     * This method should generally be avoided as it returns widgets declared in templates, which are
                     * supposed to be internal/hidden, but it's left here for back-compat reasons.
                     * 
                     */
                    getDescendants(): any[];
                    /**
                     * Function used to generate the labels of the format dropdown
                     * will return a formatted, or plain label based on the value
                     * of the plainText option.
                     * We're stuck using the deprecated FONT tag to correspond
                     * with the size measurements used by the editor
                     * 
                     * @param value The 'insert value' associated with a name             
                     * @param name The text name of the value             
                     */
                    getLabel(value: String, name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     * 
                     */
                    getParent(): any;
                    /**
                     * Return true if this widget can currently be focused
                     * and false if not
                     * 
                     */
                    isFocusable(): any;
                    /**
                     * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                     * 
                     */
                    isLeftToRight(): any;
                    /**
                     * 
                     * @param type protected             
                     * @param func             
                     */
                    on(type: String, func: Function): any;
                    /**
                     * 
                     * @param type protected             
                     * @param func             
                     */
                    on(type: Function, func: Function): any;
                    /**
                     * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                     * already removed/destroyed manually.
                     * 
                     */
                    own(): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: String, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: HTMLElement, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: dijit._WidgetBase, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: String, position: number): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: HTMLElement, position: number): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: dijit._WidgetBase, position: number): any;
                    /**
                     * Over-ride for the default postCreate action
                     * This establishes the filtering selects and the like.
                     * 
                     */
                    postCreate(): void;
                    /**
                     * Over-ride to set specific properties.
                     * 
                     */
                    postMixInProperties(): void;
                    /**
                     * Set a property on a widget
                     * Sets named properties on a widget which may potentially be handled by a
                     * setter in the widget.
                     * 
                     * For example, if the widget has properties foo and bar
                     * and a method named _setFooAttr(), calling
                     * myWidget.set("foo", "Howdy!") would be equivalent to calling
                     * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                     * would be equivalent to the statement widget.bar = 3;
                     * 
                     * set() may also be called with a hash of name/value pairs, ex:
                     * 
                     * myWidget.set({
                     *     foo: "Howdy",
                     *     bar: 3
                     * });
                     * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                     * 
                     * @param name The property to set.             
                     * @param value The value to set in the property.             
                     */
                    set(name: any, value: any): any;
                    /**
                     * Deprecated.  Use set() instead.
                     * 
                     * @param attr             
                     * @param value             
                     */
                    setAttribute(attr: String, value: any): void;
                    /**
                     * Processing after the DOM fragment is added to the document
                     * Called after a widget and its children have been created and added to the page,
                     * and all related widgets have finished their create() cycle, up through postCreate().
                     * 
                     * Note that startup() may be called while the widget is still hidden, for example if the widget is
                     * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
                     * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
                     * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
                     * 
                     */
                    startup(): void;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                     * 
                     * Subscribes to the specified topic and calls the specified method
                     * of this object and registers for unsubscribe() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.subscribe, except with the
                     * implicit use of this widget as the target object.
                     * 
                     * @param t The topic             
                     * @param method The callback             
                     */
                    subscribe(t: String, method: Function): any;
                    /**
                     * Returns a string that represents the widget.
                     * When a widget is cast to a string, this method will be used to generate the
                     * output. Currently, it does not implement any sort of reversible
                     * serialization.
                     * 
                     */
                    toString(): string;
                    /**
                     * Deprecated. Override destroy() instead to implement custom widget tear-down
                     * behavior.
                     * 
                     */
                    uninitialize(): boolean;
                    /**
                     * Deprecated, will be removed in 2.0, use handle.remove() instead.
                     * 
                     * Unsubscribes handle created by this.subscribe.
                     * Also removes handle from this widget's list of subscriptions
                     * 
                     * @param handle             
                     */
                    unsubscribe(handle: Object): void;
                    /**
                     * Watches a property for changes
                     * 
                     * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                     * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                     */
                    watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                    /**
                     * Static method to get a template based on the templatePath or
                     * templateString key
                     */
                    getCachedTemplate(): any;
                    /**
                     * Called when the widget stops being "active" because
                     * focus moved to something outside of it, or the user
                     * clicked somewhere outside of it, or the widget was
                     * hidden.
                     * 
                     */
                    onBlur(): void;
                    /**
                     * Connect to this function to receive notifications of mouse click events.
                     * 
                     * @param event mouse Event             
                     */
                    onClick(event: any): void;
                    /**
                     * Called when this widget is being displayed as a popup (ex: a Calendar popped
                     * up from a DateTextBox), and it is hidden.
                     * This is called from the dijit.popup code, and should not be called directly.
                     * 
                     * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                     * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                     * 
                     */
                    onClose(): boolean;
                    /**
                     * Connect to this function to receive notifications of mouse double click events.
                     * 
                     * @param event mouse Event             
                     */
                    onDblClick(event: any): void;
                    /**
                     * Called when the widget becomes "active" because
                     * it or a widget inside of it either has focus, or has recently
                     * been clicked.
                     * 
                     */
                    onFocus(): void;
                    /**
                     * Called when another widget becomes the selected pane in a
                     * dijit/layout/TabContainer, dijit/layout/StackContainer,
                     * dijit/layout/AccordionContainer, etc.
                     * 
                     * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                     * 
                     */
                    onHide(): void;
                    /**
                     * Connect to this function to receive notifications of keys being pressed down.
                     * 
                     * @param event key Event             
                     */
                    onKeyDown(event: any): void;
                    /**
                     * Connect to this function to receive notifications of printable keys being typed.
                     * 
                     * @param event key Event             
                     */
                    onKeyPress(event: any): void;
                    /**
                     * Connect to this function to receive notifications of keys being released.
                     * 
                     * @param event key Event             
                     */
                    onKeyUp(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse button is pressed down.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseDown(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves onto this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseEnter(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves off of this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseLeave(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseMove(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseOut(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseOver(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse button is released.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseUp(event: any): void;
                    /**
                     * Called when this widget becomes the selected pane in a
                     * dijit/layout/TabContainer, dijit/layout/StackContainer,
                     * dijit/layout/AccordionContainer, etc.
                     * 
                     * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                     * 
                     */
                    onShow(): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/FontChoice._FormatBlockDropDown.html
                 *
                 * Dropdown to select a format (like paragraph or heading); goes in editor toolbar.
                 * 
                 * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
                 * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
                 */
                class _FormatBlockDropDown extends dijit._Widget implements dijit._TemplatedMixin, dijit._WidgetsInTemplateMixin {
                    constructor(params?: Object, srcNodeRef?: HTMLElement);
                    /**
                     * Object to which attach points and events will be scoped.  Defaults
                     * to 'this'.
                     * 
                     */
                    "attachScope": Object;
                    set(property:"attachScope", value: Object): void;
                    get(property:"attachScope"): Object;
                    watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                     * for each XXX attribute to be mapped to the DOM.
                     * 
                     * attributeMap sets up a "binding" between attributes (aka properties)
                     * of the widget and the widget's DOM.
                     * Changes to widget attributes listed in attributeMap will be
                     * reflected into the DOM.
                     * 
                     * For example, calling set('title', 'hello')
                     * on a TitlePane will automatically cause the TitlePane's DOM to update
                     * with the new title.
                     * 
                     * attributeMap is a hash where the key is an attribute of the widget,
                     * and the value reflects a binding to a:
                     * 
                     * DOM node attribute
                     *   focus: {node: "focusNode", type: "attribute"}
                     * Maps this.focus to this.focusNode.focus
                     * 
                     * DOM node innerHTML
                     *   title: { node: "titleNode", type: "innerHTML" }
                     * Maps this.title to this.titleNode.innerHTML
                     * 
                     * DOM node innerText
                     *   title: { node: "titleNode", type: "innerText" }
                     * Maps this.title to this.titleNode.innerText
                     * 
                     * DOM node CSS class
                     *   myClass: { node: "domNode", type: "class" }
                     * Maps this.myClass to this.domNode.className
                     * 
                     * If the value is an array, then each element in the array matches one of the
                     * formats of the above list.
                     * 
                     * There are also some shorthands for backwards compatibility:
                     * 
                     * string --> { node: string, type: "attribute" }, for example:
                     * "focusNode" ---> { node: "focusNode", type: "attribute" }
                     * "" --> { node: "domNode", type: "attribute" }
                     * 
                     */
                    "attributeMap": Object;
                    set(property:"attributeMap", value: Object): void;
                    get(property:"attributeMap"): Object;
                    watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
                     * widget state.
                     * 
                     */
                    "baseClass": string;
                    set(property:"baseClass", value: string): void;
                    get(property:"baseClass"): string;
                    watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "class": string;
                    set(property:"class", value: string): void;
                    get(property:"class"): string;
                    watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "comboClass": string;
                    set(property:"comboClass", value: string): void;
                    get(property:"comboClass"): string;
                    watch(property:"comboClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The editor 'command' implemented by this plugin.
                     * 
                     */
                    "command": string;
                    set(property:"command", value: string): void;
                    get(property:"command"): string;
                    watch(property:"command", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Designates where children of the source DOM node will be placed.
                     * "Children" in this case refers to both DOM nodes and widgets.
                     * For example, for myWidget:
                     * 
                     * <div data-dojo-type=myWidget>
                     *     <b> here's a plain DOM node
                     *     <span data-dojo-type=subWidget>and a widget</span>
                     *     <i> and another plain DOM node </i>
                     * </div>
                     * containerNode would point to:
                     * 
                     * <b> here's a plain DOM node
                     * <span data-dojo-type=subWidget>and a widget</span>
                     * <i> and another plain DOM node </i>
                     * In templated widgets, "containerNode" is set via a
                     * data-dojo-attach-point assignment.
                     * 
                     * containerNode must be defined for any widget that accepts innerHTML
                     * (like ContentPane or BorderContainer or even Button), and conversely
                     * is null for widgets that don't, like TextBox.
                     * 
                     */
                    "containerNode": HTMLElement;
                    set(property:"containerNode", value: HTMLElement): void;
                    get(property:"containerNode"): HTMLElement;
                    watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * Bi-directional support, as defined by the HTML DIR
                     * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                     * default direction.
                     * 
                     */
                    "dir": string;
                    set(property:"dir", value: string): void;
                    get(property:"dir"): string;
                    watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * This is our visible representation of the widget! Other DOM
                     * Nodes may by assigned to other properties, usually through the
                     * template system's data-dojo-attach-point syntax, but the domNode
                     * property is the canonical "top level" node in widget UI.
                     * 
                     */
                    "domNode": HTMLElement;
                    set(property:"domNode", value: HTMLElement): void;
                    get(property:"domNode"): HTMLElement;
                    watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * This widget or a widget it contains has focus, or is "active" because
                     * it was recently clicked.
                     * 
                     */
                    "focused": boolean;
                    set(property:"focused", value: boolean): void;
                    get(property:"focused"): boolean;
                    watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * A unique, opaque ID string that can be assigned by users or by the
                     * system. If the developer passes an ID which is known not to be
                     * unique, the specified ID is ignored and the system-generated ID is
                     * used instead.
                     * 
                     */
                    "id": string;
                    set(property:"id", value: string): void;
                    get(property:"id"): string;
                    watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The label to apply to this particular FontDropDown.
                     * 
                     */
                    "label": string;
                    set(property:"label", value: string): void;
                    get(property:"label"): string;
                    watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Rarely used.  Overrides the default Dojo locale used to render this widget,
                     * as defined by the HTML LANG attribute.
                     * Value must be among the list of locales specified during by the Dojo bootstrap,
                     * formatted according to RFC 3066 (like en-us).
                     * 
                     */
                    "lang": string;
                    set(property:"lang", value: string): void;
                    get(property:"lang"): string;
                    watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The document this widget belongs to.  If not specified to constructor, will default to
                     * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                     * 
                     */
                    "ownerDocument": Object;
                    set(property:"ownerDocument", value: Object): void;
                    get(property:"ownerDocument"): Object;
                    watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * Flag to indicate that the returned label should be plain text
                     * instead of an example.
                     * 
                     */
                    "plainText": boolean;
                    set(property:"plainText", value: boolean): void;
                    get(property:"plainText"): boolean;
                    watch(property:"plainText", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * 
                     */
                    "searchContainerNode": boolean;
                    set(property:"searchContainerNode", value: boolean): void;
                    get(property:"searchContainerNode"): boolean;
                    watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * pointer to original DOM node
                     * 
                     */
                    "srcNodeRef": HTMLElement;
                    set(property:"srcNodeRef", value: HTMLElement): void;
                    get(property:"srcNodeRef"): HTMLElement;
                    watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                    /**
                     * HTML style attributes as cssText string or name/value hash
                     * 
                     */
                    "style": string;
                    set(property:"style", value: string): void;
                    get(property:"style"): string;
                    watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                     * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                     * 
                     */
                    "templatePath": string;
                    set(property:"templatePath", value: string): void;
                    get(property:"templatePath"): string;
                    watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The template used to construct the labeled dropdown.
                     * 
                     */
                    "templateString": string;
                    set(property:"templateString", value: string): void;
                    get(property:"templateString"): string;
                    watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * HTML title attribute.
                     * 
                     * For form widgets this specifies a tooltip to display when hovering over
                     * the widget (just like the native HTML title attribute).
                     * 
                     * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                     * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                     * interpreted as HTML.
                     * 
                     */
                    "title": string;
                    set(property:"title", value: string): void;
                    get(property:"title"): string;
                    watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                     * this specifies the tooltip to appear when the mouse is hovered over that text.
                     * 
                     */
                    "tooltip": string;
                    set(property:"tooltip", value: string): void;
                    get(property:"tooltip"): string;
                    watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * The HTML format tags supported by this plugin
                     * 
                     */
                    "values": any[];
                    set(property:"values", value: any[]): void;
                    get(property:"values"): any[];
                    watch(property:"values", callback:{(property?:string, oldValue?:any[], newValue?: any[]):void}) :{unwatch():void}
                    /**
                     * Should we parse the template to find widgets that might be
                     * declared in markup inside it?  (Remove for 2.0 and assume true)
                     * 
                     */
                    "widgetsInTemplate": boolean;
                    set(property:"widgetsInTemplate", value: boolean): void;
                    get(property:"widgetsInTemplate"): boolean;
                    watch(property:"widgetsInTemplate", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * This method is deprecated, use get() or set() directly.
                     * 
                     * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                     * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                     */
                    attr(name: String, value: Object): any;
                    /**
                     * This method is deprecated, use get() or set() directly.
                     * 
                     * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                     * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                     */
                    attr(name: Object, value: Object): any;
                    /**
                     * Construct the UI for this widget, setting this.domNode.
                     * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
                     * 
                     */
                    buildRendering(): void;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: String, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: String, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: Function, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: Function, method: String): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: String, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: String, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: Object, event: Function, method: Function): any;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                     * 
                     * Connects specified obj/event to specified method of this object
                     * and registers for disconnect() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.connect, except with the
                     * implicit use of this widget as the target object.
                     * Events connected with this.connect are disconnected upon
                     * destruction.
                     * 
                     * @param obj             
                     * @param event             
                     * @param method             
                     */
                    connect(obj: any, event: Function, method: Function): any;
                    /**
                     * The context require that is used to resolve modules in template.
                     * 
                     */
                    contextRequire(): void;
                    /**
                     * Wrapper to setTimeout to avoid deferred functions executing
                     * after the originating widget has been destroyed.
                     * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                     * 
                     * @param fcn Function reference.             
                     * @param delay               OptionalDelay, defaults to 0.             
                     */
                    defer(fcn: Function, delay: number): Object;
                    /**
                     * Destroy this widget, but not its descendants.  Descendants means widgets inside of
                     * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
                     * 
                     * This method will also destroy internal widgets such as those created from a template,
                     * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
                     * 
                     * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
                     * depend on the current ability to destroy a widget without destroying its descendants.   Generally
                     * they should use destroyRecursive() for widgets with children.
                     * 
                     * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
                     */
                    destroy(preserveDom?: boolean): void;
                    /**
                     * Recursively destroy the children of this widget and their
                     * descendants.
                     * 
                     * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                     */
                    destroyDescendants(preserveDom?: boolean): void;
                    /**
                     * Destroy this widget and its descendants
                     * This is the generic "destructor" function that all widget users
                     * should call to cleanly discard with a widget. Once a widget is
                     * destroyed, it is removed from the manager object.
                     * 
                     * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                     */
                    destroyRecursive(preserveDom?: boolean): void;
                    /**
                     * Destroys the DOM nodes associated with this widget.
                     * 
                     * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                     */
                    destroyRendering(preserveDom?: boolean): void;
                    /**
                     * Deprecated, will be removed in 2.0, use handle.remove() instead.
                     * 
                     * Disconnects handle created by connect.
                     * 
                     * @param handle             
                     */
                    disconnect(handle: any): void;
                    /**
                     * Used by widgets to signal that a synthetic event occurred, ex:
                     * 
                     * myWidget.emit("attrmodified-selectedChildWidget", {}).
                     * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                     * Also calls onType() method, if present, and returns value from that method.
                     * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                     * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                     * 
                     * @param type             
                     * @param eventObj               Optional            
                     * @param callbackArgs               Optional            
                     */
                    emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                    /**
                     * Over-ride for focus control of this widget.  Delegates focus down to the
                     * filtering select.
                     * 
                     */
                    focus(): void;
                    /**
                     * Get a property from a widget.
                     * Get a named property from a widget. The property may
                     * potentially be retrieved via a getter method. If no getter is defined, this
                     * just retrieves the object's property.
                     * 
                     * For example, if the widget has properties foo and bar
                     * and a method named _getFooAttr(), calling:
                     * myWidget.get("foo") would be equivalent to calling
                     * widget._getFooAttr() and myWidget.get("bar")
                     * would be equivalent to the expression
                     * widget.bar2
                     * 
                     * @param name The property to get.             
                     */
                    get(name: any): any;
                    /**
                     * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                     * is this widget.   Note that it does not return all descendants, but rather just direct children.
                     * Analogous to Node.childNodes,
                     * except containing widgets rather than DOMNodes.
                     * 
                     * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                     * outside of this.containerNode.
                     * 
                     * Note that the array returned is a simple array.  Application code should not assume
                     * existence of methods like forEach().
                     * 
                     */
                    getChildren(): any[];
                    /**
                     * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                     * This method should generally be avoided as it returns widgets declared in templates, which are
                     * supposed to be internal/hidden, but it's left here for back-compat reasons.
                     * 
                     */
                    getDescendants(): any[];
                    /**
                     * Function used to generate the labels of the format dropdown
                     * will return a formatted, or plain label based on the value
                     * of the plainText option.
                     * 
                     * @param value The 'insert value' associated with a name             
                     * @param name The text name of the value             
                     */
                    getLabel(value: String, name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     * 
                     */
                    getParent(): any;
                    /**
                     * Return true if this widget can currently be focused
                     * and false if not
                     * 
                     */
                    isFocusable(): any;
                    /**
                     * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                     * 
                     */
                    isLeftToRight(): any;
                    /**
                     * 
                     * @param type protected             
                     * @param func             
                     */
                    on(type: String, func: Function): any;
                    /**
                     * 
                     * @param type protected             
                     * @param func             
                     */
                    on(type: Function, func: Function): any;
                    /**
                     * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                     * already removed/destroyed manually.
                     * 
                     */
                    own(): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: String, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: HTMLElement, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: dijit._WidgetBase, position: String): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: String, position: number): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: HTMLElement, position: number): any;
                    /**
                     * Place this widget somewhere in the DOM based
                     * on standard domConstruct.place() conventions.
                     * A convenience function provided in all _Widgets, providing a simple
                     * shorthand mechanism to put an existing (or newly created) Widget
                     * somewhere in the dom, and allow chaining.
                     * 
                     * @param reference Widget, DOMNode, or id of widget or DOMNode             
                     * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                     */
                    placeAt(reference: dijit._WidgetBase, position: number): any;
                    /**
                     * 
                     */
                    postCreate(): void;
                    /**
                     * Over-ride to set specific properties.
                     * 
                     */
                    postMixInProperties(): void;
                    /**
                     * Set a property on a widget
                     * Sets named properties on a widget which may potentially be handled by a
                     * setter in the widget.
                     * 
                     * For example, if the widget has properties foo and bar
                     * and a method named _setFooAttr(), calling
                     * myWidget.set("foo", "Howdy!") would be equivalent to calling
                     * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                     * would be equivalent to the statement widget.bar = 3;
                     * 
                     * set() may also be called with a hash of name/value pairs, ex:
                     * 
                     * myWidget.set({
                     *     foo: "Howdy",
                     *     bar: 3
                     * });
                     * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                     * 
                     * @param name The property to set.             
                     * @param value The value to set in the property.             
                     */
                    set(name: any, value: any): any;
                    /**
                     * Deprecated.  Use set() instead.
                     * 
                     * @param attr             
                     * @param value             
                     */
                    setAttribute(attr: String, value: any): void;
                    /**
                     * Processing after the DOM fragment is added to the document
                     * Called after a widget and its children have been created and added to the page,
                     * and all related widgets have finished their create() cycle, up through postCreate().
                     * 
                     * Note that startup() may be called while the widget is still hidden, for example if the widget is
                     * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
                     * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
                     * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
                     * 
                     */
                    startup(): void;
                    /**
                     * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                     * 
                     * Subscribes to the specified topic and calls the specified method
                     * of this object and registers for unsubscribe() on widget destroy.
                     * 
                     * Provide widget-specific analog to dojo.subscribe, except with the
                     * implicit use of this widget as the target object.
                     * 
                     * @param t The topic             
                     * @param method The callback             
                     */
                    subscribe(t: String, method: Function): any;
                    /**
                     * Returns a string that represents the widget.
                     * When a widget is cast to a string, this method will be used to generate the
                     * output. Currently, it does not implement any sort of reversible
                     * serialization.
                     * 
                     */
                    toString(): string;
                    /**
                     * Deprecated. Override destroy() instead to implement custom widget tear-down
                     * behavior.
                     * 
                     */
                    uninitialize(): boolean;
                    /**
                     * Deprecated, will be removed in 2.0, use handle.remove() instead.
                     * 
                     * Unsubscribes handle created by this.subscribe.
                     * Also removes handle from this widget's list of subscriptions
                     * 
                     * @param handle             
                     */
                    unsubscribe(handle: Object): void;
                    /**
                     * Watches a property for changes
                     * 
                     * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                     * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                     */
                    watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                    /**
                     * Static method to get a template based on the templatePath or
                     * templateString key
                     */
                    getCachedTemplate(): any;
                    /**
                     * Called when the widget stops being "active" because
                     * focus moved to something outside of it, or the user
                     * clicked somewhere outside of it, or the widget was
                     * hidden.
                     * 
                     */
                    onBlur(): void;
                    /**
                     * Connect to this function to receive notifications of mouse click events.
                     * 
                     * @param event mouse Event             
                     */
                    onClick(event: any): void;
                    /**
                     * Called when this widget is being displayed as a popup (ex: a Calendar popped
                     * up from a DateTextBox), and it is hidden.
                     * This is called from the dijit.popup code, and should not be called directly.
                     * 
                     * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                     * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                     * 
                     */
                    onClose(): boolean;
                    /**
                     * Connect to this function to receive notifications of mouse double click events.
                     * 
                     * @param event mouse Event             
                     */
                    onDblClick(event: any): void;
                    /**
                     * Called when the widget becomes "active" because
                     * it or a widget inside of it either has focus, or has recently
                     * been clicked.
                     * 
                     */
                    onFocus(): void;
                    /**
                     * Called when another widget becomes the selected pane in a
                     * dijit/layout/TabContainer, dijit/layout/StackContainer,
                     * dijit/layout/AccordionContainer, etc.
                     * 
                     * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                     * 
                     */
                    onHide(): void;
                    /**
                     * Connect to this function to receive notifications of keys being pressed down.
                     * 
                     * @param event key Event             
                     */
                    onKeyDown(event: any): void;
                    /**
                     * Connect to this function to receive notifications of printable keys being typed.
                     * 
                     * @param event key Event             
                     */
                    onKeyPress(event: any): void;
                    /**
                     * Connect to this function to receive notifications of keys being released.
                     * 
                     * @param event key Event             
                     */
                    onKeyUp(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse button is pressed down.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseDown(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves onto this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseEnter(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves off of this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseLeave(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseMove(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseOut(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseOver(event: any): void;
                    /**
                     * Connect to this function to receive notifications of when the mouse button is released.
                     * 
                     * @param event mouse Event             
                     */
                    onMouseUp(event: any): void;
                    /**
                     * Called when this widget becomes the selected pane in a
                     * dijit/layout/TabContainer, dijit/layout/StackContainer,
                     * dijit/layout/AccordionContainer, etc.
                     * 
                     * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                     * 
                     */
                    onShow(): void;
                }
            }

            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/FullScreen.html
             *
             * This plugin provides FullScreen capability to the editor.  When
             * toggled on, it will render the editor into the full window and
             * overlay everything.  It also binds to the hotkey: CTRL-SHIFT-F11
             * for toggling fullscreen mode.
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class FullScreen extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                 * Passed to editor.execCommand() if useDefaultCommand is true.
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * Read-Only variable used to denote of the editor is in fullscreen mode or not.
                 * 
                 */
                "isFullscreen": boolean;
                /**
                 * If true, this plugin executes by calling Editor.execCommand() with the argument specified in command.
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * zIndex value used for overlaying the full page.
                 * default is 500.
                 * 
                 */
                "zIndex": number;
                /**
                 * Class of widget (ex: dijit.form.Button or dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * This is used to instantiate the button, unless button itself is specified directly.
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * Over-ride to ensure the resize handle gets cleaned up.
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * Over-ride for the setting of the editor.
                 * 
                 * @param editor The editor to configure for this plugin to use.             
                 */
                setEditor(editor: dijit.Editor): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Function to allow programmatic toggling of the view.
                 * 
                 */
                toggle(): void;
                /**
                 * Over-ride for button state control for disabled to work.
                 * 
                 */
                updateState(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/EnterKeyHandling.html
             *
             * This plugin tries to make all browsers behave consistently with regard to
             * how ENTER behaves in the editor window.  It traps the ENTER key and alters
             * the way DOM is constructed in certain cases to try to commonize the generated
             * DOM and behaviors across browsers.
             * This plugin has three modes:
             * 
             * blockNodeForEnter=BR
             * blockNodeForEnter=DIV
             * blockNodeForEnter=P
             * In blockNodeForEnter=P, the ENTER key starts a new
             * paragraph, and shift-ENTER starts a new line in the current paragraph.
             * For example, the input:
             * 
             * first paragraph <shift-ENTER>
             * second line of first paragraph <ENTER>
             * second paragraph
             * will generate:
             * 
             * <p>
             *     first paragraph
             *     <br/>
             *     second line of first paragraph
             * </p>
             * <p>
             *     second paragraph
             * </p>
             * In BR and DIV mode, the ENTER key conceptually goes to a new line in the
             * current paragraph, and users conceptually create a new paragraph by pressing ENTER twice.
             * For example, if the user enters text into an editor like this:
             * 
             * one <ENTER>
             * two <ENTER>
             * three <ENTER>
             * <ENTER>
             * four <ENTER>
             * five <ENTER>
             * six <ENTER>
             * It will appear on the screen as two 'paragraphs' of three lines each.  Markupwise, this generates:
             * 
             * BR:
             * 
             * one<br/>
             * two<br/>
             * three<br/>
             * <br/>
             * four<br/>
             * five<br/>
             * six<br/>
             * DIV:
             * 
             * <div>one</div>
             * <div>two</div>
             * <div>three</div>
             * <div>&nbsp;</div>
             * <div>four</div>
             * <div>five</div>
             * <div>six</div>
             * 
             * @param args This object will be passed to the plugin constructor     
             */
            class EnterKeyHandling extends dijit._editor._Plugin {
                constructor(args: any);
                /**
                 * This property decides the behavior of Enter key. It can be either P,
                 * DIV, BR, or empty (which means disable this feature). Anything else
                 * will trigger errors.  The default is 'BR'
                 * 
                 * See class description for more details.
                 * 
                 */
                "blockNodeForEnter": string;
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                 * Passed to editor.execCommand() if useDefaultCommand is true.
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * If true, this plugin executes by calling Editor.execCommand() with the argument specified in command.
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * Class of widget (ex: dijit.form.Button or dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * This is used to instantiate the button, unless button itself is specified directly.
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * 
                 * @param editor             
                 */
                setEditor(editor: any): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Change state of the plugin to respond to events in the editor.
                 * This is called on meaningful events in the editor, such as change of selection
                 * or caret position (but not simple typing of alphanumeric keys).   It gives the
                 * plugin a chance to update the CSS of its button.
                 * 
                 * For example, the "bold" plugin will highlight/unhighlight the bold button depending on whether the
                 * characters next to the caret are bold or not.
                 * 
                 * Only makes sense when useDefaultCommand is true, as it calls Editor.queryCommandEnabled(command).
                 * 
                 */
                updateState(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/LinkDialog.html
             *
             * This plugin provides the basis for an 'anchor' (link) dialog and an extension of it
             * provides the image link dialog.
             * The command provided by this plugin is:
             * 
             * createLink
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class LinkDialog extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                 * Passed to editor.execCommand() if useDefaultCommand is true.
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * Used for validating input as correct email address.  Taken from dojox.validate
                 * 
                 */
                "emailRegExp": string;
                /**
                 * String used for templating the HTML to insert at the desired point.
                 * 
                 */
                "htmlTemplate": string;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * Template for contents of TooltipDialog to pick URL
                 * 
                 */
                "linkDialogTemplate": string;
                /**
                 * Tag used for the link type.
                 * 
                 */
                "tag": string;
                /**
                 * Used for validating input as correct URL.  While file:// urls are not terribly
                 * useful, they are technically valid.
                 * 
                 */
                "urlRegExp": string;
                /**
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * 
                 */
                ImgLinkDialog(): void;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * Tell the plugin which Editor it is associated with.
                 * 
                 * @param editor             
                 */
                setEditor(editor: dijit.Editor): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Change state of the plugin to respond to events in the editor.
                 * This is called on meaningful events in the editor, such as change of selection
                 * or caret position (but not simple typing of alphanumeric keys).   It gives the
                 * plugin a chance to update the CSS of its button.
                 * 
                 * For example, the "bold" plugin will highlight/unhighlight the bold button depending on whether the
                 * characters next to the caret are bold or not.
                 * 
                 * Only makes sense when useDefaultCommand is true, as it calls Editor.queryCommandEnabled(command).
                 * 
                 */
                updateState(): void;
            }
            module LinkDialog {
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/LinkDialog.ImgLinkDialog.html
                 *
                 * This plugin extends LinkDialog and adds in a plugin for handling image links.
                 * provides the image link dialog.
                 * The command provided by this plugin is:
                 * 
                 * insertImage
                 * 
                 * @param args       OptionalInitial settings for any of the attributes.     
                 */
                class ImgLinkDialog extends dijit._editor._Plugin {
                    constructor(args?: Object);
                    /**
                     * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                     * that is added to the toolbar to control this plugin.
                     * If not specified, will be created on initialization according to buttonClass
                     * 
                     */
                    "button": Object;
                    /**
                     * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                     * Passed to editor.execCommand() if useDefaultCommand is true.
                     * 
                     */
                    "command": string;
                    /**
                     * Flag to indicate if this plugin has been disabled and should do nothing
                     * helps control button state, among other things.  Set via the setter api.
                     * 
                     */
                    "disabled": boolean;
                    /**
                     * Points to the parent editor
                     * 
                     */
                    "editor": Object;
                    /**
                     * Used for validating input as correct email address.  Taken from dojox.validate
                     * 
                     */
                    "emailRegExp": string;
                    /**
                     * String used for templating the <img> HTML to insert at the desired point.
                     * 
                     */
                    "htmlTemplate": string;
                    /**
                     * The CSS class name for the button node is formed from iconClassPrefix and command
                     * 
                     */
                    "iconClassPrefix": string;
                    /**
                     * Over-ride for template since img dialog doesn't need target that anchor tags may.
                     * 
                     */
                    "linkDialogTemplate": string;
                    /**
                     * Tag used for the link type (img).
                     * 
                     */
                    "tag": string;
                    /**
                     * Used for validating input as correct URL.  While file:// urls are not terribly
                     * useful, they are technically valid.
                     * 
                     */
                    "urlRegExp": string;
                    /**
                     * 
                     */
                    "useDefaultCommand": boolean;
                    /**
                     * 
                     */
                    buttonClass(): void;
                    /**
                     * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                     * 
                     * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                     * Similar to dijit/_Widget.connect().
                     * 
                     * @param o             
                     * @param f             
                     * @param tf             
                     */
                    connect(o: any, f: any, tf: any): void;
                    /**
                     * 
                     */
                    destroy(): void;
                    /**
                     * Get a property from a plugin.
                     * Get a named property from a plugin. The property may
                     * potentially be retrieved via a getter method. If no getter is defined, this
                     * just retrieves the object's property.
                     * For example, if the plugin has a properties "foo"
                     * and "bar" and a method named "_getFooAttr", calling:
                     * 
                     * plugin.get("foo");
                     * would be equivalent to writing:
                     * 
                     * plugin._getFooAttr();
                     * and:
                     * 
                     * plugin.get("bar");
                     * would be equivalent to writing:
                     * 
                     * plugin.bar;
                     * 
                     * @param name The property to get.             
                     */
                    get(name: any): any;
                    /**
                     * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                     * already removed/destroyed manually.
                     * 
                     */
                    own(): any;
                    /**
                     * Set a property on a plugin
                     * Sets named properties on a plugin which may potentially be handled by a
                     * setter in the plugin.
                     * For example, if the plugin has a properties "foo"
                     * and "bar" and a method named "_setFooAttr", calling:
                     * 
                     * plugin.set("foo", "Howdy!");
                     * would be equivalent to writing:
                     * 
                     * plugin._setFooAttr("Howdy!");
                     * and:
                     * 
                     * plugin.set("bar", 3);
                     * would be equivalent to writing:
                     * 
                     * plugin.bar = 3;
                     * set() may also be called with a hash of name/value pairs, ex:
                     * 
                     * plugin.set({
                     *     foo: "Howdy",
                     *     bar: 3
                     * })
                     * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                     * 
                     * @param name The property to set.             
                     * @param value The value to set in the property.             
                     */
                    set(name: Attr, value: any): any;
                    /**
                     * Tell the plugin which Editor it is associated with.
                     * 
                     * @param editor             
                     */
                    setEditor(editor: dijit.Editor): void;
                    /**
                     * Tell the plugin to add it's controller widget (often a button)
                     * to the toolbar.  Does nothing if there is no controller widget.
                     * 
                     * @param toolbar             
                     */
                    setToolbar(toolbar: dijit.Toolbar): void;
                    /**
                     * Change state of the plugin to respond to events in the editor.
                     * This is called on meaningful events in the editor, such as change of selection
                     * or caret position (but not simple typing of alphanumeric keys).   It gives the
                     * plugin a chance to update the CSS of its button.
                     * 
                     * For example, the "bold" plugin will highlight/unhighlight the bold button depending on whether the
                     * characters next to the caret are bold or not.
                     * 
                     * Only makes sense when useDefaultCommand is true, as it calls Editor.queryCommandEnabled(command).
                     * 
                     */
                    updateState(): void;
                }
            }

            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/TextColor.html
             *
             * This plugin provides dropdown color pickers for setting text color and background color
             * The commands provided by this plugin are:
             * 
             * foreColor - sets the text color
             * hiliteColor - sets the background color
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class TextColor extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                 * Passed to editor.execCommand() if useDefaultCommand is true.
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * False as we do not use the default editor command/click behavior.
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * Tell the plugin which Editor it is associated with.
                 * 
                 * @param editor             
                 */
                setEditor(editor: dijit.Editor): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Overrides _Plugin.updateState().  This updates the ColorPalette
                 * to show the color of the currently selected text.
                 * 
                 */
                updateState(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/NewPage.html
             *
             * This plugin provides a simple 'new page' capability.  In other
             * words, set content to some default user defined string.
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class NewPage extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                 * Passed to editor.execCommand() if useDefaultCommand is true.
                 * 
                 */
                "command": string;
                /**
                 * The default content to insert into the editor as the new page.
                 * The default is the <br> tag, a single blank line.
                 * 
                 */
                "content": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * If true, this plugin executes by calling Editor.execCommand() with the argument specified in command.
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * Class of widget (ex: dijit.form.Button or dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * This is used to instantiate the button, unless button itself is specified directly.
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * Tell the plugin which Editor it is associated with.
                 * 
                 * @param editor The editor object to attach the newPage capability to.             
                 */
                setEditor(editor: dijit.Editor): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Over-ride for button state control for disabled to work.
                 * 
                 */
                updateState(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/Print.html
             *
             * This plugin provides Print capability to the editor.  When
             * clicked, the document in the editor frame will be printed.
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class Print extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                 * Passed to editor.execCommand() if useDefaultCommand is true.
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * If true, this plugin executes by calling Editor.execCommand() with the argument specified in command.
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * Class of widget (ex: dijit.form.Button or dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * This is used to instantiate the button, unless button itself is specified directly.
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * Tell the plugin which Editor it is associated with.
                 * 
                 * @param editor The editor object to attach the print capability to.             
                 */
                setEditor(editor: dijit.Editor): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Over-ride for button state control for disabled to work.
                 * 
                 */
                updateState(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/TabIndent.html
             *
             * This plugin is used to allow the use of the tab and shift-tab keys
             * to indent/outdent list items.  This overrides the default behavior
             * of moving focus from/to the toolbar
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class TabIndent extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * Tell the plugin which Editor it is associated with.
                 * 
                 * @param editor             
                 */
                setEditor(editor: dijit.Editor): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * 
                 */
                updateState(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/ToggleDir.html
             *
             * This plugin is used to toggle direction of the edited document,
             * independent of what direction the whole page is.
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class ToggleDir extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * Tell the plugin which Editor it is associated with.
                 * 
                 * @param editor             
                 */
                setEditor(editor: dijit.Editor): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Over-ride for button state control for disabled to work.
                 * 
                 */
                updateState(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/plugins/ViewSource.html
             *
             * This plugin provides a simple view source capability.  When view
             * source mode is enabled, it disables all other buttons/plugins on the RTE.
             * It also binds to the hotkey: CTRL-SHIFT-F11 for toggling ViewSource mode.
             * 
             * @param args       OptionalInitial settings for any of the attributes.     
             */
            class ViewSource extends dijit._editor._Plugin {
                constructor(args?: Object);
                /**
                 * Pointer to dijit/form/Button or other widget (ex: dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * If not specified, will be created on initialization according to buttonClass
                 * 
                 */
                "button": Object;
                /**
                 * String like "insertUnorderedList", "outdent", "justifyCenter", etc. that represents an editor command.
                 * Passed to editor.execCommand() if useDefaultCommand is true.
                 * 
                 */
                "command": string;
                /**
                 * Flag to indicate if this plugin has been disabled and should do nothing
                 * helps control button state, among other things.  Set via the setter api.
                 * 
                 */
                "disabled": boolean;
                /**
                 * Points to the parent editor
                 * 
                 */
                "editor": Object;
                /**
                 * The CSS class name for the button node is formed from iconClassPrefix and command
                 * 
                 */
                "iconClassPrefix": string;
                /**
                 * Boolean flag used to indicate if the source view should be readonly or not.
                 * Cannot be changed after initialization of the plugin.
                 * Defaults to false.
                 * 
                 */
                "readOnly": boolean;
                /**
                 * Boolean flag used to indicate if comment tags should be stripped from the document.
                 * Defaults to true.
                 * 
                 */
                "stripComments": boolean;
                /**
                 * 
                 */
                "stripIFrames": boolean;
                /**
                 * Boolean flag used to indicate if script tags should be stripped from the document.
                 * Defaults to true.
                 * 
                 */
                "stripScripts": boolean;
                /**
                 * If true, this plugin executes by calling Editor.execCommand() with the argument specified in command.
                 * 
                 */
                "useDefaultCommand": boolean;
                /**
                 * Class of widget (ex: dijit.form.Button or dijit/form/FilteringSelect)
                 * that is added to the toolbar to control this plugin.
                 * This is used to instantiate the button, unless button itself is specified directly.
                 * 
                 */
                buttonClass(): void;
                /**
                 * Deprecated.  Use this.own() with dojo/on or dojo/aspect.instead.
                 * 
                 * Make a connect.connect() that is automatically disconnected when this plugin is destroyed.
                 * Similar to dijit/_Widget.connect().
                 * 
                 * @param o             
                 * @param f             
                 * @param tf             
                 */
                connect(o: any, f: any, tf: any): void;
                /**
                 * Over-ride to remove the node used to correct for IE's
                 * zoom bug.
                 * 
                 */
                destroy(): void;
                /**
                 * Get a property from a plugin.
                 * Get a named property from a plugin. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_getFooAttr", calling:
                 * 
                 * plugin.get("foo");
                 * would be equivalent to writing:
                 * 
                 * plugin._getFooAttr();
                 * and:
                 * 
                 * plugin.get("bar");
                 * would be equivalent to writing:
                 * 
                 * plugin.bar;
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Set a property on a plugin
                 * Sets named properties on a plugin which may potentially be handled by a
                 * setter in the plugin.
                 * For example, if the plugin has a properties "foo"
                 * and "bar" and a method named "_setFooAttr", calling:
                 * 
                 * plugin.set("foo", "Howdy!");
                 * would be equivalent to writing:
                 * 
                 * plugin._setFooAttr("Howdy!");
                 * and:
                 * 
                 * plugin.set("bar", 3);
                 * would be equivalent to writing:
                 * 
                 * plugin.bar = 3;
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * plugin.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * })
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: Attr, value: any): any;
                /**
                 * Tell the plugin which Editor it is associated with.
                 * 
                 * @param editor The editor object to attach the print capability to.             
                 */
                setEditor(editor: dijit.Editor): void;
                /**
                 * Internal function to set the caret in the sourceArea
                 * to 0x0
                 * 
                 */
                setSourceAreaCaret(): void;
                /**
                 * Tell the plugin to add it's controller widget (often a button)
                 * to the toolbar.  Does nothing if there is no controller widget.
                 * 
                 * @param toolbar             
                 */
                setToolbar(toolbar: dijit.Toolbar): void;
                /**
                 * Function to allow programmatic toggling of the view.
                 * 
                 */
                toggle(): void;
                /**
                 * Over-ride for button state control for disabled to work.
                 * 
                 */
                updateState(): void;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/html.html
         *
         * HTML serialization utility functions used by editor
         * 
         */
        interface html {
            /**
             * Adds escape sequences for special characters in XML: &<>"'.
             * Optionally skips escapes for single quotes.
             * 
             * @param str             
             * @param noSingleQuotes               Optional            
             */
            escapeXml(str: String, noSingleQuotes: boolean): any;
            /**
             * Returns the html content of a DomNode's children
             * 
             * @param node             
             */
            getChildrenHtml(node: HTMLElement): any;
            /**
             * Pushes the html content of a DomNode's children into out[]
             * 
             * @param dom             
             * @param output an array of arrays of points             
             */
            getChildrenHtmlHelper(dom: HTMLElement, output: String[]): void;
            /**
             * Return string representing HTML for node and it's children
             * 
             * @param node             
             */
            getNodeHtml(node: HTMLElement): any;
            /**
             * Pushes array of strings into output[] which represent HTML for node and it's children
             * 
             * @param node             
             * @param output             
             */
            getNodeHtmlHelper(node: HTMLElement, output: String[]): String;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/range.html
         *
         * W3C range API
         * 
         */
        interface range {
            /**
             * 
             */
            BlockTagNames: RegExp;
            /**
             * 
             */
            ie: Object;
            /**
             * 
             * @param startnode             
             * @param next             
             */
            adjacentNoneTextNode(startnode: any, next: any): any[];
            /**
             * 
             * @param container             
             * @param node             
             * @param offset             
             */
            atBeginningOfContainer(container: HTMLElement, node: HTMLElement, offset: number): boolean;
            /**
             * 
             * @param container             
             * @param node             
             * @param offset             
             */
            atEndOfContainer(container: HTMLElement, node: HTMLElement, offset: number): boolean;
            /**
             * 
             * @param win               Optional            
             */
            create(win: Window): any;
            /**
             * 
             * @param node             
             * @param regex               Optional            
             * @param root               Optional            
             */
            getAncestor(node: HTMLElement, regex: RegExp, root: HTMLElement): HTMLElement;
            /**
             * 
             * @param node             
             * @param regex               Optional            
             * @param root               Optional            
             */
            getBlockAncestor(node: HTMLElement, regex: RegExp, root: HTMLElement): Object;
            /**
             * 
             * @param n1             
             * @param n2             
             * @param root             
             */
            getCommonAncestor(n1: any, n2: any, root: any): any;
            /**
             * 
             * @param node             
             * @param parent             
             */
            getIndex(node: HTMLElement, parent: HTMLElement): Object;
            /**
             * 
             * @param index             
             * @param parent             
             */
            getNode(index: any[], parent: HTMLElement): HTMLElement;
            /**
             * 
             * @param window             
             * @param ignoreUpdate               Optional            
             */
            getSelection(window: Window, ignoreUpdate: boolean): any;
            /**
             * 
             */
            W3CRange(): void;
        }
        module range {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/range.W3CRange.html
             *
             * 
             */
            class W3CRange {
                constructor();
                /**
                 * 
                 */
                cloneRange(): any;
                /**
                 * 
                 */
                deleteContents(): void;
                /**
                 * 
                 */
                detach(): void;
                /**
                 * 
                 */
                getBookmark(): any;
                /**
                 * 
                 * @param node             
                 * @param offset             
                 */
                setEnd(node: any, offset: any): void;
                /**
                 * 
                 * @param node             
                 * @param offset             
                 */
                setEndAfter(node: any, offset: any): void;
                /**
                 * 
                 * @param node             
                 * @param offset             
                 */
                setEndBefore(node: any, offset: any): void;
                /**
                 * 
                 * @param node             
                 * @param offset             
                 */
                setStart(node: any, offset: any): void;
                /**
                 * 
                 * @param node             
                 * @param offset             
                 */
                setStartAfter(node: any, offset: any): void;
                /**
                 * 
                 * @param node             
                 * @param offset             
                 */
                setStartBefore(node: any, offset: any): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/range.ie.html
             *
             * 
             */
            interface ie {
                /**
                 * 
                 */
                cachedSelection: Object;
                /**
                 * 
                 * @param range             
                 */
                decomposeControlRange(range: any): any[];
                /**
                 * 
                 * @param range             
                 */
                decomposeTextRange(range: any): any[];
                /**
                 * 
                 * @param range             
                 * @param end             
                 */
                getEndPoint(range: any, end: any): any[];
                /**
                 * 
                 * @param window             
                 */
                selection(window: any): void;
                /**
                 * 
                 * @param range             
                 * @param container             
                 * @param offset             
                 */
                setEndPoint(range: any, container: any, offset: any): any;
                /**
                 * 
                 * @param range             
                 * @param startContainer             
                 * @param startOffset             
                 * @param endContainer             
                 * @param endOffset             
                 * @param collapsed             
                 */
                setRange(range: any, startContainer: any, startOffset: any, endContainer: any, endOffset: any, collapsed: any): any;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_editor/selection.html
         *
         * Deprecated text selection API.  Will be removed in 2.0.  New code should use dijit/selection.
         * 
         */
        interface selection {
            /**
             * Function to collapse (clear), the current selection
             * 
             * @param beginning Indicates whether to collapse the cursor to the beginning of the selection or end.             
             */
            collapse(beginning: boolean): void;
            /**
             * Return the parent element of the current selection which is of
             * type tagName (or one of the other specified tagName)
             * 
             * @param tagName The tag name to determine if it has an ancestor of.             
             */
            getAncestorElement(tagName: String): any;
            /**
             * Get the parent element of the current selection
             * 
             */
            getParentElement(): any;
            /**
             * Function to locate a parent node that matches one of a set of tags
             * 
             * @param node The node to inspect.             
             * @param tags             
             */
            getParentOfType(node: HTMLElement, tags: String[]): HTMLElement;
            /**
             * Retrieves the selected element (if any), just in the case that
             * a single element (object like and image or a table) is
             * selected.
             * 
             */
            getSelectedElement(): any;
            /**
             * Return the html text of the current selection or null if unavailable
             * 
             */
            getSelectedHtml(): String;
            /**
             * Return the text (no html tags) included in the current selection or null if no text is selected
             * 
             */
            getSelectedText(): String;
            /**
             * Get the selection type (like win.doc.select.type in IE).
             * 
             */
            getType(): String;
            /**
             * Check whether current selection has a  parent element which is
             * of type tagName (or one of the other specified tagName)
             * 
             * @param tagName The tag name to determine if it has an ancestor of.             
             */
            hasAncestorElement(tagName: String): boolean;
            /**
             * This function determines if 'node' is
             * in the current selection.
             * 
             * @param node             
             */
            inSelection(node: any): boolean;
            /**
             * Function to determine if a node is one of an array of tags.
             * 
             * @param node The node to inspect.             
             * @param tags             
             */
            isTag(node: HTMLElement, tags: String[]): any;
            /**
             * Function to delete the currently selected content from the document.
             * 
             */
            remove(): any;
            /**
             * clear previous selection and select element (including all its children)
             * 
             * @param element The element to select.             
             * @param nochangefocus               OptionalBoolean indicating if the focus should be changed.  IE only.             
             */
            selectElement(element: HTMLElement, nochangefocus: boolean): void;
            /**
             * clear previous selection and select the content of the node
             * (excluding the node itself)
             * 
             * @param element The element you wish to select the children content of.             
             * @param nochangefocus               OptionalIndicates if the focus should change or not.             
             */
            selectElementChildren(element: HTMLElement, nochangefocus: boolean): void;
        }
    }

    module _tree {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_tree/dndSource.html
         *
         * Deprecated module, use dijit/tree/dndSource instead.
         * 
         */
        interface dndSource {
        }
    }

    module form {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_ButtonMixin.html
         *
         * 
         */
        class _ButtonMixin {
            constructor();
            /**
             * Content to display in button.
             * 
             */
            "label": string;
            /**
             * Type of button (submit, reset, button, checkbox, radio)
             * 
             */
            "type": string;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Callback for when button is clicked.
             * If type="submit", return true to perform submit, or false to cancel it.
             * 
             * @param e             
             */
            onClick(e: Event): boolean;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_CheckBoxMixin.html
         *
         * Mixin to provide widget functionality corresponding to an HTML checkbox
         * User interacts with real html inputs.
         * On onclick (which occurs by mouse click, space-bar, or
         * using the arrow keys to switch the selected radio button),
         * we update the state of the checkbox/radio.
         * 
         */
        class _CheckBoxMixin {
            constructor();
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            /**
             * As an initialization parameter, equivalent to value field on normal checkbox
             * (if checked, the value is passed as the value when form is submitted).
             * 
             */
            "value": string;
            /**
             * 
             */
            reset(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_AutoCompleterMixin.html
         *
         * A mixin that implements the base functionality for dijit/form/ComboBox/dijit/form/FilteringSelect
         * All widgets that mix in dijit/form/_AutoCompleterMixin must extend dijit/form/_FormValueWidget.
         * 
         */
        class _AutoCompleterMixin extends dijit.form._SearchMixin {
            constructor();
            /**
             * If user types in a partial string, and then tab out of the <input> box,
             * automatically copy the first entry displayed in the drop down list to
             * the <input> field
             * 
             */
            "autoComplete": boolean;
            /**
             * Mixin to the store's fetch.
             * For example, to set the sort order of the ComboBox menu, pass:
             * 
             * { sort: [{attribute:"name",descending: true}] }
             * To override the default queryOptions so that deep=false, do:
             * 
             * { queryOptions: {ignoreCase: true, deep: false} }
             * 
             */
            "fetchProperties": Object;
            /**
             * One of: "first", "all" or "none".
             * 
             * If the ComboBox/FilteringSelect opens with the search results and the searched
             * string can be found, it will be highlighted.  If set to "all"
             * then will probably want to change queryExpr parameter to '${0}'
             * 
             * Highlighting is only performed when labelType is "text", so as to not
             * interfere with any HTML markup an HTML label might contain.
             * 
             */
            "highlightMatch": string;
            /**
             * Set true if the query should ignore case when matching possible items
             * 
             */
            "ignoreCase": boolean;
            /**
             * This is the item returned by the dojo/store/api/Store implementation that
             * provides the data for this ComboBox, it's the currently selected item.
             * 
             */
            "item": Object;
            /**
             * The entries in the drop down list come from this attribute in the
             * dojo.data items.
             * If not specified, the searchAttr attribute is used instead.
             * 
             */
            "labelAttr": Object;
            /**
             * Specifies how to interpret the labelAttr in the data store items.
             * Can be "html" or "text".
             * 
             */
            "labelType": string;
            /**
             * 
             */
            "maxHeight": number;
            /**
             * Argument to data provider.
             * Specifies maximum number of search results to return per query
             * 
             */
            "pageSize": number;
            /**
             * A query that can be passed to store to initially filter the items.
             * ComboBox overwrites any reference to the searchAttr and sets it to the queryExpr with the user's input substituted.
             * 
             */
            "query": Object;
            /**
             * This specifies what query is sent to the data store,
             * based on what the user has typed.  Changing this expression will modify
             * whether the results are only exact matches, a "starting with" match,
             * etc.
             * ${0} will be substituted for the user text.
             * * is used for wildcards.
             * ${0}* means "starts with", *${0}* means "contains", ${0} means "is"
             * 
             */
            "queryExpr": string;
            /**
             * Search for items in the data store where this attribute (in the item)
             * matches what the user typed
             * 
             */
            "searchAttr": string;
            /**
             * Delay in milliseconds between when user types something and we start
             * searching based on that value
             * 
             */
            "searchDelay": number;
            /**
             * Reference to data provider object used by this ComboBox.
             * The store must accept an object hash of properties for its query. See query and queryExpr for details.
             * 
             */
            "store": Object;
            /**
             * 
             */
            closeDropDown(): void;
            /**
             * Highlights the string entered by the user in the menu.  By default this
             * highlights the first occurrence found. Override this method
             * to implement your custom highlighting.
             * 
             * @param label             
             * @param find             
             */
            doHighlight(label: String, find: String): any;
            /**
             * 
             */
            isLoaded(): boolean;
            /**
             * 
             * @param callback             
             */
            loadDropDown(callback: Function): void;
            /**
             * Subclasses must call this method from their postCreate() methods
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Callback when a search completes.
             * 
             * @param results An array of items from the originating _SearchMixin's store.             
             * @param query A copy of the originating _SearchMixin's query property.             
             * @param options The additional parameters sent to the originating _SearchMixin's store, including: start, count, queryOptions.             
             */
            onSearch(results: Object, query: Object, options: Object): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_ExpandingTextAreaMixin.html
         *
         * Mixin for textarea widgets to add auto-expanding capability
         * 
         */
        class _ExpandingTextAreaMixin {
            constructor();
            /**
             * 
             */
            postCreate(): void;
            /**
             * Resizes the textarea vertically (should be called after a style/value change)
             * 
             */
            resize(): void;
            /**
             * 
             */
            startup(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_ComboBoxMenuMixin.html
         *
         * 
         */
        class _ComboBoxMenuMixin {
            constructor();
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Clears the entries in the drop down list, but of course keeps the previous and next buttons.
             * 
             */
            clearResultList(): void;
            /**
             * Fills in the items in the drop down list
             * 
             * @param results Array of items             
             * @param options The options to the query function of the store             
             * @param labelFunc Function to produce a label in the drop down list from a dojo.data item             
             */
            createOptions(results: any, options: any, labelFunc: any): void;
            /**
             * 
             */
            getHighlightedOption(): any;
            /**
             * Highlight the first real item in the list (not Previous Choices).
             * 
             */
            highlightFirstOption(): void;
            /**
             * Highlight the last real item in the list (not More Choices).
             * 
             */
            highlightLastOption(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * 
             */
            selectFirstNode(): void;
            /**
             * 
             */
            selectLastNode(): void;
            /**
             * Notifies ComboBox/FilteringSelect that user selected an option.
             * 
             * @param direction             
             */
            onChange(direction: number): void;
            /**
             * 
             * @param node             
             */
            onClick(node: HTMLElement): void;
            /**
             * Notifies ComboBox/FilteringSelect that user clicked to advance to next/previous page.
             * 
             * @param direction             
             */
            onPage(direction: number): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_FormMixin.html
         *
         * Mixin for containers of form widgets (i.e. widgets that represent a single value
         * and can be children of a <form> node or dijit/form/Form widget)
         * Can extract all the form widgets
         * values and combine them into a single javascript object, or alternately
         * take such an object and set the values for all the contained
         * form widgets
         * 
         */
        class _FormMixin {
            constructor();
            /**
             * Will be "Error" if one or more of the child widgets has an invalid value,
             * "Incomplete" if not all of the required child widgets are filled in.  Otherwise, "",
             * which indicates that the form is ready to be submitted.
             * 
             */
            "state": string;
            /**
             * You can call this function directly, ex. in the event that you
             * programmatically add a widget to the form after the form has been
             * initialized.
             * 
             * @param inStartup             
             */
            connectChildren(inStartup: boolean): void;
            /**
             * 
             */
            destroy(): void;
            /**
             * Deprecated method.   Applications no longer need to call this.   Remove for 2.0.
             * 
             */
            disconnectChildren(): void;
            /**
             * 
             */
            getValues(): any;
            /**
             * Returns true if all of the widgets are valid.
             * Deprecated, will be removed in 2.0.  Use get("state") instead.
             * 
             */
            isValid: {(): boolean};
            /**
             * 
             */
            reset(): void;
            /**
             * 
             * @param val             
             */
            setValues(val: any): any;
            /**
             * 
             */
            startup(): void;
            /**
             * returns if the form is valid - same as isValid - but
             * provides a few additional (ui-specific) features:
             * 
             * it will highlight any sub-widgets that are not valid
             * it will call focus() on the first invalid sub-widget
             * 
             */
            validate(): any;
            /**
             * Stub function to connect to if you want to do something
             * (like disable/enable a submit button) when the valid
             * state changes on the form as a whole.
             * 
             * Deprecated.  Will be removed in 2.0.  Use watch("state", ...) instead.
             * 
             * @param isValid             
             */
            onValidStateChange(isValid: boolean): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_FormValueMixin.html
         *
         * Mixin for widgets corresponding to native HTML elements such as <input> or <select>
         * that have user changeable values.
         * Each _FormValueMixin represents a single input value, and has a (possibly hidden) <input> element,
         * to which it serializes it's input value, so that form submission (either normal submission or via FormBind?)
         * works as expected.
         * 
         */
        class _FormValueMixin extends dijit.form._FormWidgetMixin {
            constructor();
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            /**
             * 
             */
            "aria-label": string;
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": Object;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * 
             */
            create(): void;
            /**
             * 
             */
            destroy(): void;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Tells if this widget is focusable or not.  Used internally by dijit.
             * 
             */
            isFocusable(): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_ComboBoxMenu.html
         *
         * Focus-less menu for internal use in dijit/form/ComboBox
         * Abstract methods that must be defined externally:
         * 
         * onChange: item was explicitly chosen (mousedown somewhere on the menu and mouseup somewhere on the menu)
         * onPage: next(1) or previous(-1) button pressed
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _ComboBoxMenu extends dijit._WidgetBase implements dijit._TemplatedMixin, dijit.form._ListMouseMixin, dijit.form._ComboBoxMenuMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * currently selected node
             * 
             */
            "selected": HTMLElement;
            set(property:"selected", value: HTMLElement): void;
            get(property:"selected"): HTMLElement;
            watch(property:"selected", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Clears the entries in the drop down list, but of course keeps the previous and next buttons.
             * 
             */
            clearResultList(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Fills in the items in the drop down list
             * 
             * @param results Array of items             
             * @param options The options to the query function of the store             
             * @param labelFunc Function to produce a label in the drop down list from a dojo.data item             
             */
            createOptions(results: any, options: any, labelFunc: any): void;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * 
             */
            getHighlightedOption(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Handle keystroke event forwarded from ComboBox, returning false if it's
             * a keystroke I recognize and process, true otherwise.
             * 
             * @param evt             
             */
            handleKey(evt: any): boolean;
            /**
             * Highlight the first real item in the list (not Previous Choices).
             * 
             */
            highlightFirstOption(): void;
            /**
             * Highlight the last real item in the list (not More Choices).
             * 
             */
            highlightLastOption(): void;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
             * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
             * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
             * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
             * 
             * @param type Name of event (ex: "click") or extension event like touch.press.             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
             * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
             * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
             * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
             * 
             * @param type Name of event (ex: "click") or extension event like touch.press.             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Select the first displayed item in the list.
             * 
             */
            selectFirstNode(): void;
            /**
             * Select the last displayed item in the list
             * 
             */
            selectLastNode(): void;
            /**
             * Select the item just below the current selection.
             * If nothing selected, select first node.
             * 
             */
            selectNextNode(): void;
            /**
             * Select the item just above the current selection.
             * If nothing selected, select last node (if
             * you select Previous and try to keep scrolling up the list).
             * 
             */
            selectPreviousNode(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Notifies ComboBox/FilteringSelect that user selected an option.
             * 
             * @param direction             
             */
            onChange(direction: number): void;
            /**
             * 
             * @param node             
             */
            onClick(node: HTMLElement): void;
            /**
             * Remove selected CSS
             * 
             * @param node             
             */
            onDeselect(node: HTMLElement): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Add hover CSS
             * 
             * @param node             
             */
            onHover(node: HTMLElement): void;
            /**
             * Notifies ComboBox/FilteringSelect that user clicked to advance to next/previous page.
             * 
             * @param direction             
             */
            onPage(direction: number): void;
            /**
             * Add selected CSS
             * 
             * @param node             
             */
            onSelect(node: HTMLElement): void;
            /**
             * Remove hover CSS
             * 
             * @param node             
             */
            onUnhover(node: HTMLElement): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_FormWidgetMixin.html
         *
         * Mixin for widgets corresponding to native HTML elements such as <checkbox> or <button>,
         * which can be children of a <form> node or a dijit/form/Form widget.
         * Represents a single HTML element.
         * All these widgets should have these attributes just like native HTML input elements.
         * You can set them during widget construction or afterwards, via dijit/_WidgetBase.set().
         * 
         * They also share some common methods.
         * 
         */
        class _FormWidgetMixin {
            constructor();
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            /**
             * 
             */
            "aria-label": string;
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": Object;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * 
             */
            create(): void;
            /**
             * 
             */
            destroy(): void;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Tells if this widget is focusable or not.  Used internally by dijit.
             * 
             */
            isFocusable(): any;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_DateTimeTextBox.html
         *
         * Base class for validating, serializable, range-bound date or time text box.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree     
         */
        class _DateTimeTextBox extends dijit.form.RangeBoundTextBox implements dijit._HasDropDown {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "autoWidth": boolean;
            set(property:"autoWidth", value: boolean): void;
            get(property:"autoWidth"): boolean;
            watch(property:"autoWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Despite the name, this parameter specifies both constraints on the input
             * (including starting/ending dates/times allowed) as well as
             * formatting options like whether the date is displayed in long (ex: December 25, 2005)
             * or short (ex: 12/25/2005) format.  See dijit/form/_DateTimeTextBox.__Constraints for details.
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * JavaScript namespace to find calendar routines.  If unspecified, uses Gregorian calendar routines
             * at dojo/date and dojo/date/locale.
             * 
             */
            "datePackage": string;
            set(property:"datePackage", value: string): void;
            get(property:"datePackage"): string;
            watch(property:"datePackage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            set(property:"dropDown", value: Object): void;
            get(property:"dropDown"): Object;
            watch(property:"dropDown", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The default value to focus in the popupClass widget when the textbox value is empty.
             * 
             */
            "dropDownDefaultValue": Date;
            set(property:"dropDownDefaultValue", value: Date): void;
            get(property:"dropDownDefaultValue"): Date;
            watch(property:"dropDownDefaultValue", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            set(property:"dropDownPosition", value: Object): void;
            get(property:"dropDownPosition"): Object;
            watch(property:"dropDownPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            set(property:"forceWidth", value: boolean): void;
            get(property:"forceWidth"): boolean;
            watch(property:"forceWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this textbox to display a down arrow button, to open the drop down list.
             * 
             */
            "hasDownArrow": boolean;
            set(property:"hasDownArrow", value: boolean): void;
            get(property:"hasDownArrow"): boolean;
            watch(property:"hasDownArrow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The max height for our dropdown.
             * Any dropdown taller than this will have scrollbars.
             * Set to 0 for no max height, or -1 to limit height to available space in viewport
             * 
             */
            "maxHeight": number;
            set(property:"maxHeight", value: number): void;
            get(property:"maxHeight"): number;
            watch(property:"maxHeight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name of the popup widget class used to select a date/time.
             * Subclasses should specify this.
             * 
             */
            "popupClass": any;
            set(property:"popupClass", value: any): void;
            get(property:"popupClass"): any;
            watch(property:"popupClass", callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is out-of-range
             * 
             */
            "rangeMessage": string;
            set(property:"rangeMessage", value: string): void;
            get(property:"rangeMessage"): string;
            watch(property:"rangeMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The value of this widget as a JavaScript Date object.  Use get("value") / set("value", val) to manipulate.
             * When passed to the parser in markup, must be specified according to dojo/date/stamp.fromISOString()
             * 
             */
            "value": Date;
            set(property:"value", value: Date): void;
            get(property:"value"): Date;
            watch(property:"value", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus: boolean): void;
            /**
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: Date, val2: Date): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Formats the value as a Date, according to specified locale (second argument)
             * 
             * @param value             
             * @param constraints An object with the following properties:selector (String): choice of 'time','date' (default: date and time)formatLength (String): choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'datePattern (String): override pattern with this stringtimePattern (String): override pattern with this stringam (String): override strings for am in timespm (String): override strings for pm in timeslocale (String): override the locale used to determine formatting rulesfullYear (Boolean): (format only) use 4 digit years whenever 2 digit years are called forstrict (Boolean): (parse only) strict parsing, off by default            
             */
            format(value: Date, constraints: Object): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Tests if the value is in the min/max range specified in constraints
             * 
             * @param isFocused             
             */
            isInRange(isFocused: boolean): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Returns true if the dropdown exists and it's data is loaded.  This can
             * be overridden in order to force a call to loadDropDown().
             * 
             */
            isLoaded(): boolean;
            /**
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): any};
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and then calls
             * the given callback.
             * 
             * @param loadCallback             
             */
            loadDropDown(loadCallback: Function): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * 
             * @param callback             
             */
            openDropDown(callback?: Function): void;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Parses as string as a Date, according to constraints
             * 
             * @param value             
             * @param constraints An object with the following properties:selector (String): choice of 'time','date' (default: date and time)formatLength (String): choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'datePattern (String): override pattern with this stringtimePattern (String): override pattern with this stringam (String): override strings for am in timespm (String): override strings for pm in timeslocale (String): override the locale used to determine formatting rulesfullYear (Boolean): (format only) use 4 digit years whenever 2 digit years are called forstrict (Boolean): (parse only) strict parsing, off by default            
             */
            parse(value: String, constraints: Object): any;
            /**
             * Builds the regular needed to parse a localized date
             * 
             * @param options               OptionalAn object with the following properties:selector (String): choice of 'time','date' (default: date and time)formatLength (String): choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'datePattern (String): override pattern with this stringtimePattern (String): override pattern with this stringam (String): override strings for am in timespm (String): override strings for pm in timeslocale (String): override the locale used to determine formatting rulesfullYear (Boolean): (format only) use 4 digit years whenever 2 digit years are called forstrict (Boolean): (parse only) strict parsing, off by default            
             */
            pattern: {(options: Object): any};
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Overridable function used to validate the range of the numeric input value.
             * 
             * @param primitive             
             * @param constraints             
             */
            rangeCheck(primitive: number, constraints: dijit.form.RangeBoundTextBox.__Constraints): boolean;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): any;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module _DateTimeTextBox {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_DateTimeTextBox.__Constraints.html
             *
             * Specifies both the rules on valid/invalid values (first/last date/time allowed),
             * and also formatting options for how the date/time is displayed.
             * 
             */
            class __Constraints {
                constructor();
                /**
                 * override strings for am in times
                 * 
                 */
                "am": string;
                /**
                 * override pattern with this string
                 * 
                 */
                "datePattern": string;
                /**
                 * choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'
                 * 
                 */
                "formatLength": string;
                /**
                 * (format only) use 4 digit years whenever 2 digit years are called for
                 * 
                 */
                "fullYear": boolean;
                /**
                 * override the locale used to determine formatting rules
                 * 
                 */
                "locale": string;
                /**
                 * Maximum signed value.  Default is +Infinity
                 * 
                 */
                "max": number;
                /**
                 * Minimum signed value.  Default is -Infinity
                 * 
                 */
                "min": number;
                /**
                 * override strings for pm in times
                 * 
                 */
                "pm": string;
                /**
                 * choice of 'time','date' (default: date and time)
                 * 
                 */
                "selector": string;
                /**
                 * (parse only) strict parsing, off by default
                 * 
                 */
                "strict": boolean;
                /**
                 * override pattern with this string
                 * 
                 */
                "timePattern": string;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_FormSelectWidget.html
         *
         * Extends _FormValueWidget in order to provide "select-specific"
         * values - i.e., those values that are unique to <select> elements.
         * This also provides the mechanism for reading the elements from
         * a store, if desired.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree     
         */
        class _FormSelectWidget extends dijit.form._FormValueWidget {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The entries in the drop down list come from this attribute in the dojo.store items.
             * If store is set, labelAttr must be set too, unless store is an old-style
             * dojo.data store rather than a new dojo/store.
             * 
             */
            "labelAttr": Object;
            set(property:"labelAttr", value: Object): void;
            get(property:"labelAttr"): Object;
            watch(property:"labelAttr", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * By default loadChildren is called when the items are fetched from the
             * store.  This property allows delaying loadChildren (and the creation
             * of the options/menuitems) until the user clicks the button to open the
             * dropdown.
             * 
             */
            "loadChildrenOnOpen": boolean;
            set(property:"loadChildrenOnOpen", value: boolean): void;
            get(property:"loadChildrenOnOpen"): boolean;
            watch(property:"loadChildrenOnOpen", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Whether or not we are multi-valued
             * 
             */
            "multiple": boolean;
            set(property:"multiple", value: boolean): void;
            get(property:"multiple"): boolean;
            watch(property:"multiple", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A callback to do with an onFetch - but before any items are actually
             * iterated over (i.e. to filter even further what you want to add)
             * 
             */
            "onFetch": Function;
            set(property:"onFetch", value: Function): void;
            get(property:"onFetch"): Function;
            watch(property:"onFetch", callback:{(property?:string, oldValue?:Function, newValue?: Function):void}) :{unwatch():void}
            /**
             * This is the dojo.Deferred returned by setStore().
             * Calling onLoadDeferred.then() registers your
             * callback to be called only once, when the prior setStore completes.
             * 
             */
            "onLoadDeferred": Object;
            set(property:"onLoadDeferred", value: Object): void;
            get(property:"onLoadDeferred"): Object;
            watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The set of options for our select item.  Roughly corresponds to
             * the html <option> tag.
             * 
             */
            "options": Object;
            set(property:"options", value: Object): void;
            get(property:"options"): Object;
            watch(property:"options", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * A query to use when fetching items from our store
             * 
             */
            "query": Object;
            set(property:"query", value: Object): void;
            get(property:"query"): Object;
            watch(property:"query", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Query options to use when fetching from the store
             * 
             */
            "queryOptions": Object;
            set(property:"queryOptions", value: Object): void;
            get(property:"queryOptions"): Object;
            watch(property:"queryOptions", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Flag to sort the options returned from a store by the label of
             * the store.
             * 
             */
            "sortByLabel": boolean;
            set(property:"sortByLabel", value: boolean): void;
            get(property:"sortByLabel"): boolean;
            watch(property:"sortByLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * A store to use for getting our list of options - rather than reading them
             * from the <option> html tags.   Should support getIdentity().
             * For back-compat store can also be a dojo/data/api/Identity.
             * 
             */
            "store": Object;
            set(property:"store", value: Object): void;
            get(property:"store"): Object;
            watch(property:"store", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A string that represents the widget template.
             * Use in conjunction with dojo.cache() to load from a file.
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Adds an option or options to the end of the select.  If value
             * of the option is empty or missing, a separator is created instead.
             * Passing in an array of options will yield slightly better performance
             * since the children are only loaded once.
             * 
             * @param option             
             */
            addOption(option: dijit.form._FormSelectWidget.__SelectOption): void;
            /**
             * Adds an option or options to the end of the select.  If value
             * of the option is empty or missing, a separator is created instead.
             * Passing in an array of options will yield slightly better performance
             * since the children are only loaded once.
             * 
             * @param option             
             */
            addOption(option: dijit.form._FormSelectWidget.__SelectOption[]): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Clean up our connections
             * 
             */
            destroy(): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns a given option (or options).
             * 
             * @param valueOrIdx If passed in as a string, that string is used to look up the optionin the array of options - based on the value property.(See dijit/form/_FormSelectWidget.__SelectOption).If passed in a number, then the option with the given index (0-based)within this select will be returned.If passed in a dijit/form/_FormSelectWidget.__SelectOption, the same option will bereturned if and only if it exists within this select.If passed an array, then an array will be returned with each elementin the array being looked up.If not passed a value, then all options will be returned             
             */
            getOptions(valueOrIdx: any): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * sets up our event handling that we need for functioning
             * as a select
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the given option or options.  You can remove by string
             * (in which case the value is removed), number (in which case the
             * index in the options array is removed), or select option (in
             * which case, the select option with a matching value is removed).
             * You can also pass in an array of those values for a slightly
             * better performance since the children are only loaded once.
             * For numeric option values, specify {value: number} as the argument.
             * 
             * @param valueOrIdx             
             */
            removeOption(valueOrIdx: String): void;
            /**
             * Removes the given option or options.  You can remove by string
             * (in which case the value is removed), number (in which case the
             * index in the options array is removed), or select option (in
             * which case, the select option with a matching value is removed).
             * You can also pass in an array of those values for a slightly
             * better performance since the children are only loaded once.
             * For numeric option values, specify {value: number} as the argument.
             * 
             * @param valueOrIdx             
             */
            removeOption(valueOrIdx: dijit.form._FormSelectWidget.__SelectOption): void;
            /**
             * Removes the given option or options.  You can remove by string
             * (in which case the value is removed), number (in which case the
             * index in the options array is removed), or select option (in
             * which case, the select option with a matching value is removed).
             * You can also pass in an array of those values for a slightly
             * better performance since the children are only loaded once.
             * For numeric option values, specify {value: number} as the argument.
             * 
             * @param valueOrIdx             
             */
            removeOption(valueOrIdx: number): void;
            /**
             * Removes the given option or options.  You can remove by string
             * (in which case the value is removed), number (in which case the
             * index in the options array is removed), or select option (in
             * which case, the select option with a matching value is removed).
             * You can also pass in an array of those values for a slightly
             * better performance since the children are only loaded once.
             * For numeric option values, specify {value: number} as the argument.
             * 
             * @param valueOrIdx             
             */
            removeOption(valueOrIdx: any[]): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Sets the store you would like to use with this select widget.
             * The selected value is the value of the new store to set.  This
             * function returns the original store, in case you want to reuse
             * it or something.
             * 
             * @param store The dojo.store you would like to use - it MUST implement getIdentity()and MAY implement observe().For backwards-compatibility this can also be a data.data store, in which caseit MUST implement dojo/data/api/Identity,and MAY implement dojo/data/api/Notification.             
             * @param selectedValue               OptionalThe value that this widget should set itself to after the storehas been loaded             
             * @param fetchArgs               OptionalHash of parameters to set filter on store, etc.query: new value for Select.query,queryOptions: new value for Select.queryOptions,onFetch: callback function for each item in data (Deprecated)             
             */
            setStore(store: dojo.store.api.Store, selectedValue: any, fetchArgs: Object): any;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Updates the values of the given option.  The option to update
             * is matched based on the value of the entered option.  Passing
             * in an array of new options will yield better performance since
             * the children will only be loaded once.
             * 
             * @param newOption             
             */
            updateOption(newOption: dijit.form._FormSelectWidget.__SelectOption): void;
            /**
             * Updates the values of the given option.  The option to update
             * is matched based on the value of the entered option.  Passing
             * in an array of new options will yield better performance since
             * the children will only be loaded once.
             * 
             * @param newOption             
             */
            updateOption(newOption: dijit.form._FormSelectWidget.__SelectOption[]): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * a function that can be connected to in order to receive a
             * notification that the store has finished loading and all options
             * from that store are available
             * 
             */
            onSetStore(): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module _FormSelectWidget {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_FormSelectWidget.__SelectOption.html
             *
             * 
             */
            interface __SelectOption {
                /**
                 * Whether or not this specific option is disabled
                 * 
                 */
                disabled?: boolean;
                /**
                 * The label for our option.  It can contain html tags.
                 * 
                 */
                label: string;
                /**
                 * Whether or not we are a selected option
                 * 
                 */
                selected?: boolean;
                /**
                 * The value of the option.  Setting to empty (or missing) will
                 * place a separator at that location
                 * 
                 */
                value: string;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_FormValueWidget.html
         *
         * Base class for widgets corresponding to native HTML elements such as <input> or <select>
         * that have user changeable values.
         * Each _FormValueWidget represents a single input value, and has a (possibly hidden) <input> element,
         * to which it serializes it's input value, so that form submission (either normal submission or via FormBind?)
         * works as expected.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _FormValueWidget extends dijit.form._FormWidget implements dijit.form._FormValueMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A string that represents the widget template.
             * Use in conjunction with dojo.cache() to load from a file.
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": any;
            set(property:"value", value: any): void;
            get(property:"value"): any;
            watch(property:"value", callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * 
             */
            create(): void;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_FormWidget.html
         *
         * Base class for widgets corresponding to native HTML elements such as <checkbox> or <button>,
         * which can be children of a <form> node or a dijit/form/Form widget.
         * Represents a single HTML element.
         * All these widgets should have these attributes just like native HTML input elements.
         * You can set them during widget construction or afterwards, via dijit/_WidgetBase.set().
         * 
         * They also share some common methods.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _FormWidget extends dijit._Widget implements dijit._TemplatedMixin, dijit._CssStateMixin, dijit.form._FormWidgetMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A string that represents the widget template.
             * Use in conjunction with dojo.cache() to load from a file.
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": Object;
            set(property:"value", value: Object): void;
            get(property:"value"): Object;
            watch(property:"value", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * 
             */
            create(): void;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_ListBase.html
         *
         * Focus-less menu to handle UI events consistently.
         * Abstract methods that must be defined externally:
         * 
         * onSelect: item is active (mousedown but not yet mouseup, or keyboard arrow selected but no Enter)
         * onDeselect:  cancels onSelect
         * 
         */
        class _ListBase {
            constructor();
            /**
             * currently selected node
             * 
             */
            "selected": HTMLElement;
            /**
             * Select the first displayed item in the list.
             * 
             */
            selectFirstNode(): void;
            /**
             * Select the last displayed item in the list
             * 
             */
            selectLastNode(): void;
            /**
             * Select the item just below the current selection.
             * If nothing selected, select first node.
             * 
             */
            selectNextNode(): void;
            /**
             * Select the item just above the current selection.
             * If nothing selected, select last node (if
             * you select Previous and try to keep scrolling up the list).
             * 
             */
            selectPreviousNode(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_RadioButtonMixin.html
         *
         * Mixin to provide widget functionality for an HTML radio button
         * 
         */
        class _RadioButtonMixin {
            constructor();
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_ListMouseMixin.html
         *
         * A mixin to handle mouse or touch events for a focus-less menu
         * Abstract methods that must be defined externally:
         * 
         * onClick: item was chosen (mousedown somewhere on the menu and mouseup somewhere on the menu)
         * 
         */
        class _ListMouseMixin extends dijit.form._ListBase {
            constructor();
            /**
             * currently selected node
             * 
             */
            "selected": HTMLElement;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Select the first displayed item in the list.
             * 
             */
            selectFirstNode(): void;
            /**
             * Select the last displayed item in the list
             * 
             */
            selectLastNode(): void;
            /**
             * Select the item just below the current selection.
             * If nothing selected, select first node.
             * 
             */
            selectNextNode(): void;
            /**
             * Select the item just above the current selection.
             * If nothing selected, select last node (if
             * you select Previous and try to keep scrolling up the list).
             * 
             */
            selectPreviousNode(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_ToggleButtonMixin.html
         *
         * A mixin to provide functionality to allow a button that can be in two states (checked or not).
         * 
         */
        class _ToggleButtonMixin {
            constructor();
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * In markup, specified as "checked='checked'" or just "checked".
             * True if the button is depressed, or the checkbox is checked,
             * or the radio button is selected, etc.
             * 
             */
            "checked": boolean;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_SearchMixin.html
         *
         * A mixin that implements the base functionality to search a store based upon user-entered text such as
         * with dijit/form/ComboBox or dijit/form/FilteringSelect
         * 
         */
        class _SearchMixin {
            constructor();
            /**
             * Mixin to the store's fetch.
             * For example, to set the sort order of the ComboBox menu, pass:
             * 
             * { sort: [{attribute:"name",descending: true}] }
             * To override the default queryOptions so that deep=false, do:
             * 
             * { queryOptions: {ignoreCase: true, deep: false} }
             * 
             */
            "fetchProperties": Object;
            /**
             * Set true if the query should ignore case when matching possible items
             * 
             */
            "ignoreCase": boolean;
            /**
             * Argument to data provider.
             * Specifies maximum number of search results to return per query
             * 
             */
            "pageSize": number;
            /**
             * A query that can be passed to store to initially filter the items.
             * ComboBox overwrites any reference to the searchAttr and sets it to the queryExpr with the user's input substituted.
             * 
             */
            "query": Object;
            /**
             * This specifies what query is sent to the data store,
             * based on what the user has typed.  Changing this expression will modify
             * whether the results are only exact matches, a "starting with" match,
             * etc.
             * ${0} will be substituted for the user text.
             * * is used for wildcards.
             * ${0}* means "starts with", *${0}* means "contains", ${0} means "is"
             * 
             */
            "queryExpr": string;
            /**
             * Search for items in the data store where this attribute (in the item)
             * matches what the user typed
             * 
             */
            "searchAttr": string;
            /**
             * Delay in milliseconds between when user types something and we start
             * searching based on that value
             * 
             */
            "searchDelay": number;
            /**
             * Reference to data provider object used by this ComboBox.
             * The store must accept an object hash of properties for its query. See query and queryExpr for details.
             * 
             */
            "store": Object;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Callback when a search completes.
             * 
             * @param results An array of items from the originating _SearchMixin's store.             
             * @param query A copy of the originating _SearchMixin's query property.             
             * @param options The additional parameters sent to the originating _SearchMixin's store, including: start, count, queryOptions.             
             */
            onSearch(results: Object, query: Object, options: Object): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_TextBoxMixin.html
         *
         * 
         */
        class _TextBoxMixin {
            constructor();
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Select text in the input element argument, from start (default 0), to stop (default end).
             * 
             * @param element             
             * @param start               Optional            
             * @param stop               Optional            
             */
            selectInputText(element: HTMLElement, start: number, stop: number): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/ComboBoxMixin.html
         *
         * Provides main functionality of ComboBox widget
         * 
         */
        class ComboBoxMixin extends dijit._HasDropDown implements dijit.form._AutoCompleterMixin {
            constructor();
            /**
             * If user types in a partial string, and then tab out of the <input> box,
             * automatically copy the first entry displayed in the drop down list to
             * the <input> field
             * 
             */
            "autoComplete": boolean;
            /**
             * Set to true to make the drop down at least as wide as this
             * widget.  Set to false if the drop down should just be its
             * default width.
             * 
             */
            "autoWidth": boolean;
            /**
             * 
             */
            "baseClass": string;
            /**
             * 
             */
            "cssStateNodes": Object;
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            /**
             * Mixin to the store's fetch.
             * For example, to set the sort order of the ComboBox menu, pass:
             * 
             * { sort: [{attribute:"name",descending: true}] }
             * To override the default queryOptions so that deep=false, do:
             * 
             * { queryOptions: {ignoreCase: true, deep: false} }
             * 
             */
            "fetchProperties": Object;
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            /**
             * Set this textbox to have a down arrow button, to display the drop down list.
             * Defaults to true.
             * 
             */
            "hasDownArrow": boolean;
            /**
             * One of: "first", "all" or "none".
             * 
             * If the ComboBox/FilteringSelect opens with the search results and the searched
             * string can be found, it will be highlighted.  If set to "all"
             * then will probably want to change queryExpr parameter to '${0}'
             * 
             * Highlighting is only performed when labelType is "text", so as to not
             * interfere with any HTML markup an HTML label might contain.
             * 
             */
            "highlightMatch": string;
            /**
             * Set true if the query should ignore case when matching possible items
             * 
             */
            "ignoreCase": boolean;
            /**
             * This is the item returned by the dojo/store/api/Store implementation that
             * provides the data for this ComboBox, it's the currently selected item.
             * 
             */
            "item": Object;
            /**
             * The entries in the drop down list come from this attribute in the
             * dojo.data items.
             * If not specified, the searchAttr attribute is used instead.
             * 
             */
            "labelAttr": Object;
            /**
             * Specifies how to interpret the labelAttr in the data store items.
             * Can be "html" or "text".
             * 
             */
            "labelType": string;
            /**
             * The max height for our dropdown.
             * Any dropdown taller than this will have scrollbars.
             * Set to 0 for no max height, or -1 to limit height to available space in viewport
             * 
             */
            "maxHeight": number;
            /**
             * Argument to data provider.
             * Specifies maximum number of search results to return per query
             * 
             */
            "pageSize": number;
            /**
             * A query that can be passed to store to initially filter the items.
             * ComboBox overwrites any reference to the searchAttr and sets it to the queryExpr with the user's input substituted.
             * 
             */
            "query": Object;
            /**
             * This specifies what query is sent to the data store,
             * based on what the user has typed.  Changing this expression will modify
             * whether the results are only exact matches, a "starting with" match,
             * etc.
             * ${0} will be substituted for the user text.
             * * is used for wildcards.
             * ${0}* means "starts with", *${0}* means "contains", ${0} means "is"
             * 
             */
            "queryExpr": string;
            /**
             * Search for items in the data store where this attribute (in the item)
             * matches what the user typed
             * 
             */
            "searchAttr": string;
            /**
             * Delay in milliseconds between when user types something and we start
             * searching based on that value
             * 
             */
            "searchDelay": number;
            /**
             * Reference to data provider object used by this ComboBox.
             * 
             * Should be dojo/store/api/Store, but dojo/data/api/Read supported
             * for backwards compatibility.
             * 
             */
            "store": Object;
            /**
             * 
             */
            "templateString": string;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus?: boolean): void;
            /**
             * 
             */
            destroy(): void;
            /**
             * Highlights the string entered by the user in the menu.  By default this
             * highlights the first occurrence found. Override this method
             * to implement your custom highlighting.
             * 
             * @param label             
             * @param find             
             */
            doHighlight(label: String, find: String): any;
            /**
             * Dropdown widget class used to select a date/time.
             * Subclasses should specify this.
             * 
             */
            dropDownClass(): void;
            /**
             * Returns true if the dropdown exists and it's data is loaded.  This can
             * be overridden in order to force a call to loadDropDown().
             * 
             */
            isLoaded(): boolean;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and then calls
             * the given callback.
             * 
             * @param loadCallback             
             */
            loadDropDown(loadCallback: Function): void;
            /**
             * Opens the dropdown for this widget.   To be called only when this.dropDown
             * has been created and is ready to display (ie, it's data is loaded).
             * 
             */
            openDropDown(): any;
            /**
             * set up nodes and connect our mouse and keyboard events
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Callback when a search completes.
             * 
             * @param results An array of items from the originating _SearchMixin's store.             
             * @param query A copy of the originating _SearchMixin's query property.             
             * @param options The additional parameters sent to the originating _SearchMixin's store, including: start, count, queryOptions.             
             */
            onSearch(results: Object, query: Object, options: Object): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/Button.html
         *
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class Button extends dijit.form._FormWidget implements dijit.form._ButtonMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Class to apply to DOMNode in button to make it display an icon
             * 
             */
            "iconClass": string;
            set(property:"iconClass", value: string): void;
            get(property:"iconClass"): string;
            watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Content to display in button.
             * 
             */
            "label": string;
            set(property:"label", value: string): void;
            get(property:"label"): string;
            watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this to true to hide the label text and display only the icon.
             * (If showLabel=false then iconClass must be specified.)
             * Especially useful for toolbars.
             * If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
             * 
             * The exception case is for computers in high-contrast mode, where the label
             * will still be displayed, since the icon doesn't appear.
             * 
             */
            "showLabel": boolean;
            set(property:"showLabel", value: boolean): void;
            get(property:"showLabel"): boolean;
            watch(property:"showLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('label', ...) instead.
             * 
             * @param content             
             */
            setLabel(content: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: Event): boolean;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/DataList.html
         *
         * Inefficient but small data store specialized for inlined data via OPTION tags
         * Provides a store for inlined data like:
         * 
         * <datalist>
         *     <option value="AL">Alabama</option>
         *     ...
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef Attach widget to this DOM node.     
         */
        class DataList extends dojo.store.Memory {
            constructor(params: Object, srcNodeRef: HTMLElement);
            /**
             * The array of all the objects in the memory store
             * 
             */
            "data": any[];
            /**
             * Indicates the property to use as the identity property. The values of this
             * property should be unique.
             * 
             */
            "idProperty": string;
            /**
             * An index of data indices into the data array by id
             * 
             */
            "index": Object;
            /**
             * Creates an object, throws an error if the object already exists
             * 
             * @param object The object to store.             
             * @param options               OptionalAdditional metadata for storing the data.  Includes an "id"property if a specific id is to be used.             
             */
            add(object: Object, options: dojo.store.api.Store.PutDirectives): any;
            /**
             * 
             */
            destroy(): void;
            /**
             * Get the option marked as selected, like <option selected>.
             * Not part of dojo.data API.
             * 
             */
            fetchSelectedItem(): any;
            /**
             * Retrieves an object by its identity
             * 
             * @param id The identity to use to lookup the object             
             */
            get(id: number): any;
            /**
             * Retrieves the children of an object.
             * 
             * @param parent The object to find the children of.             
             * @param options               OptionalAdditional options to apply to the retrieval of the children.             
             */
            getChildren(parent: Object, options: dojo.store.api.Store.QueryOptions): dojo.store.api.Store.QueryResults;
            /**
             * Returns an object's identity
             * 
             * @param object The object to get the identity from             
             */
            getIdentity(object: Object): any;
            /**
             * Returns any metadata about the object. This may include attribution,
             * cache directives, history, or version information.
             * 
             * @param object The object to return metadata for.             
             */
            getMetadata(object: Object): Object;
            /**
             * Stores an object
             * 
             * @param object The object to store.             
             * @param options               OptionalAdditional metadata for storing the data.  Includes an "id"property if a specific id is to be used.             
             */
            put(object: Object, options: dojo.store.api.Store.PutDirectives): any;
            /**
             * Queries the store for objects.
             * 
             * @param query The query to use for retrieving objects from the store.             
             * @param options               OptionalThe optional arguments to apply to the resultset.             
             */
            query(query: Object, options: dojo.store.api.Store.QueryOptions): any;
            /**
             * Defines the query engine to use for querying the data store
             * 
             * @param query An object hash with fields that may match fields of items in the store.Values in the hash will be compared by normal == operator, but regular expressionsor any object that provides a test() method are also supported and can beused to match strings by more complex expressions(and then the regex's or object's test() method will be used to match values).             
             * @param options               OptionalAn object that contains optional information such as sort, start, and count.             
             */
            queryEngine(query: Object, options: dojo.store.api.Store.QueryOptions): any;
            /**
             * Deletes an object by its identity
             * 
             * @param id The identity to use to delete the object             
             */
            remove(id: number): any;
            /**
             * Sets the given data as the source for this store, and indexes it
             * 
             * @param data An array of objects to use as the source of data.             
             */
            setData(data: Object[]): void;
            /**
             * Starts a new transaction.
             * Note that a store user might not call transaction() prior to using put,
             * delete, etc. in which case these operations effectively could be thought of
             * as "auto-commit" style actions.
             * 
             */
            transaction(): dojo.store.api.Store.Transaction;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/_Spinner.html
         *
         * Mixin for validation widgets with a spinner.
         * This class basically (conceptually) extends dijit/form/ValidationTextBox.
         * It modifies the template to have up/down arrows, and provides related handling code.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class _Spinner extends dijit.form.RangeBoundTextBox {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Number of milliseconds before a held arrow key or up/down button becomes typematic
             * 
             */
            "defaultTimeout": number;
            set(property:"defaultTimeout", value: number): void;
            get(property:"defaultTimeout"): number;
            watch(property:"defaultTimeout", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Adjust the value by this much when spinning using the PgUp/Dn keys
             * 
             */
            "largeDelta": number;
            set(property:"largeDelta", value: number): void;
            get(property:"largeDelta"): number;
            watch(property:"largeDelta", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * minimum number of milliseconds that typematic event fires when held key or button is held
             * 
             */
            "minimumTimeout": number;
            set(property:"minimumTimeout", value: number): void;
            get(property:"minimumTimeout"): number;
            watch(property:"minimumTimeout", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This defines the regular expression used to validate the input.
             * Do not add leading ^ or $ characters since the widget adds these.
             * A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
             * set('pattern', String|Function).
             * 
             */
            "pattern": string;
            set(property:"pattern", value: string): void;
            get(property:"pattern"): string;
            watch(property:"pattern", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is out-of-range
             * 
             */
            "rangeMessage": string;
            set(property:"rangeMessage", value: string): void;
            get(property:"rangeMessage"): string;
            watch(property:"rangeMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Adjust the value by this much when spinning using the arrow keys/buttons
             * 
             */
            "smallDelta": number;
            set(property:"smallDelta", value: number): void;
            get(property:"smallDelta"): number;
            watch(property:"smallDelta", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fraction of time used to change the typematic timer between events.
             * 1.0 means that each typematic event fires at defaultTimeout intervals.
             * Less than 1.0 means that each typematic event fires at an increasing faster rate.
             * 
             */
            "timeoutChangeRate": number;
            set(property:"timeoutChangeRate", value: number): void;
            get(property:"timeoutChangeRate"): number;
            watch(property:"timeoutChangeRate", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Overridable function used to adjust a primitive value(Number/Date/...) by the delta amount specified.
             * The val is adjusted in a way that makes sense to the object type.
             * 
             * @param val             
             * @param delta             
             */
            adjust(val: Object, delta: number): Object;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Tests if the value is in the min/max range specified in constraints
             * 
             * @param isFocused             
             */
            isInRange(isFocused: boolean): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): any};
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Overridable function used to validate the range of the numeric input value.
             * 
             * @param primitive             
             * @param constraints             
             */
            rangeCheck(primitive: number, constraints: dijit.form.RangeBoundTextBox.__Constraints): boolean;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Overridable function used to convert the get('value') result to a canonical
             * (non-localized) string.  For example, will print dates in ISO format, and
             * numbers the same way as they are represented in javascript.
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): String;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/CheckBox.html
         *
         * Same as an HTML checkbox, but with fancy styling.
         * User interacts with real html inputs.
         * On onclick (which occurs by mouse click, space-bar, or
         * using the arrow keys to switch the selected radio button),
         * we update the state of the checkbox/radio.
         * 
         * There are two modes:
         * 
         * High contrast mode
         * Normal mode
         * In case 1, the regular html inputs are shown and used by the user.
         * In case 2, the regular html inputs are invisible but still used by
         * the user. They are turned quasi-invisible and overlay the background-image.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class CheckBox extends dijit.form.ToggleButton implements dijit.form._CheckBoxMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * In markup, specified as "checked='checked'" or just "checked".
             * True if the button is depressed, or the checkbox is checked,
             * or the radio button is selected, etc.
             * 
             */
            "checked": boolean;
            set(property:"checked", value: boolean): void;
            get(property:"checked"): boolean;
            watch(property:"checked", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Class to apply to DOMNode in button to make it display an icon
             * 
             */
            "iconClass": string;
            set(property:"iconClass", value: string): void;
            get(property:"iconClass"): string;
            watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Content to display in button.
             * 
             */
            "label": string;
            set(property:"label", value: string): void;
            get(property:"label"): string;
            watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this to true to hide the label text and display only the icon.
             * (If showLabel=false then iconClass must be specified.)
             * Especially useful for toolbars.
             * If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
             * 
             * The exception case is for computers in high-contrast mode, where the label
             * will still be displayed, since the icon doesn't appear.
             * 
             */
            "showLabel": boolean;
            set(property:"showLabel", value: boolean): void;
            get(property:"showLabel"): boolean;
            watch(property:"showLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('checked', true/false) instead.
             * 
             * @param checked             
             */
            setChecked(checked: boolean): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('label', ...) instead.
             * 
             * @param content             
             */
            setLabel(content: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: Event): boolean;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/ComboButton.html
         *
         * A combination button and drop-down button.
         * Users can click one side to "press" the button, or click an arrow
         * icon to display the drop down.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class ComboButton extends dijit.form.DropDownButton {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down at least as wide as this
             * widget.  Set to false if the drop down should just be its
             * default width.
             * 
             */
            "autoWidth": boolean;
            set(property:"autoWidth", value: boolean): void;
            get(property:"autoWidth"): boolean;
            watch(property:"autoWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            set(property:"dropDown", value: Object): void;
            get(property:"dropDown"): Object;
            watch(property:"dropDown", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            set(property:"dropDownPosition", value: Object): void;
            get(property:"dropDownPosition"): Object;
            watch(property:"dropDownPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            set(property:"forceWidth", value: boolean): void;
            get(property:"forceWidth"): boolean;
            watch(property:"forceWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Class to apply to DOMNode in button to make it display an icon
             * 
             */
            "iconClass": string;
            set(property:"iconClass", value: string): void;
            get(property:"iconClass"): string;
            watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Content to display in button.
             * 
             */
            "label": string;
            set(property:"label", value: string): void;
            get(property:"label"): string;
            watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The max height for our dropdown.
             * Any dropdown taller than this will have scrollbars.
             * Set to 0 for no max height, or -1 to limit height to available space in viewport
             * 
             */
            "maxHeight": number;
            set(property:"maxHeight", value: number): void;
            get(property:"maxHeight"): number;
            watch(property:"maxHeight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Text that describes the options menu (accessibility)
             * 
             */
            "optionsTitle": string;
            set(property:"optionsTitle", value: string): void;
            get(property:"optionsTitle"): string;
            watch(property:"optionsTitle", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this to true to hide the label text and display only the icon.
             * (If showLabel=false then iconClass must be specified.)
             * Especially useful for toolbars.
             * If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
             * 
             * The exception case is for computers in high-contrast mode, where the label
             * will still be displayed, since the icon doesn't appear.
             * 
             */
            "showLabel": boolean;
            set(property:"showLabel", value: boolean): void;
            get(property:"showLabel"): boolean;
            watch(property:"showLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus: boolean): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Focuses this widget to according to position, if specified,
             * otherwise on arrow node
             * 
             * @param position "start" or "end"             
             */
            focus(position?: String): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            isLoaded(): boolean;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * 
             * @param callback             
             */
            loadDropDown(callback: Function): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Opens the dropdown for this widget.   To be called only when this.dropDown
             * has been created and is ready to display (ie, it's data is loaded).
             * 
             */
            openDropDown(): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('label', ...) instead.
             * 
             * @param content             
             */
            setLabel(content: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): boolean;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/ComboBox.html
         *
         * Auto-completing text box
         * The drop down box's values are populated from an class called
         * a data provider, which returns a list of values based on the characters
         * that the user has typed into the input box.
         * If OPTION tags are used as the data provider via markup,
         * then the OPTION tag's child text node is used as the widget value
         * when selected.  The OPTION tag's value attribute is ignored.
         * To set the default value when using OPTION tags, specify the selected
         * attribute on 1 of the child OPTION tags.
         * 
         * Some of the options to the ComboBox are actually arguments to the data
         * provider.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class ComboBox extends dijit.form.ValidationTextBox implements dijit.form.ComboBoxMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * If user types in a partial string, and then tab out of the <input> box,
             * automatically copy the first entry displayed in the drop down list to
             * the <input> field
             * 
             */
            "autoComplete": boolean;
            set(property:"autoComplete", value: boolean): void;
            get(property:"autoComplete"): boolean;
            watch(property:"autoComplete", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down at least as wide as this
             * widget.  Set to false if the drop down should just be its
             * default width.
             * 
             */
            "autoWidth": boolean;
            set(property:"autoWidth", value: boolean): void;
            get(property:"autoWidth"): boolean;
            watch(property:"autoWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * user-defined object needed to pass parameters to the validator functions
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            set(property:"dropDown", value: Object): void;
            get(property:"dropDown"): Object;
            watch(property:"dropDown", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            set(property:"dropDownPosition", value: Object): void;
            get(property:"dropDownPosition"): Object;
            watch(property:"dropDownPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Mixin to the store's fetch.
             * For example, to set the sort order of the ComboBox menu, pass:
             * 
             * { sort: [{attribute:"name",descending: true}] }
             * To override the default queryOptions so that deep=false, do:
             * 
             * { queryOptions: {ignoreCase: true, deep: false} }
             * 
             */
            "fetchProperties": Object;
            set(property:"fetchProperties", value: Object): void;
            get(property:"fetchProperties"): Object;
            watch(property:"fetchProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            set(property:"forceWidth", value: boolean): void;
            get(property:"forceWidth"): boolean;
            watch(property:"forceWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this textbox to have a down arrow button, to display the drop down list.
             * Defaults to true.
             * 
             */
            "hasDownArrow": boolean;
            set(property:"hasDownArrow", value: boolean): void;
            get(property:"hasDownArrow"): boolean;
            watch(property:"hasDownArrow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * One of: "first", "all" or "none".
             * 
             * If the ComboBox/FilteringSelect opens with the search results and the searched
             * string can be found, it will be highlighted.  If set to "all"
             * then will probably want to change queryExpr parameter to '${0}'
             * 
             * Highlighting is only performed when labelType is "text", so as to not
             * interfere with any HTML markup an HTML label might contain.
             * 
             */
            "highlightMatch": string;
            set(property:"highlightMatch", value: string): void;
            get(property:"highlightMatch"): string;
            watch(property:"highlightMatch", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Set true if the query should ignore case when matching possible items
             * 
             */
            "ignoreCase": boolean;
            set(property:"ignoreCase", value: boolean): void;
            get(property:"ignoreCase"): boolean;
            watch(property:"ignoreCase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is the item returned by the dojo/store/api/Store implementation that
             * provides the data for this ComboBox, it's the currently selected item.
             * 
             */
            "item": Object;
            set(property:"item", value: Object): void;
            get(property:"item"): Object;
            watch(property:"item", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The entries in the drop down list come from this attribute in the
             * dojo.data items.
             * If not specified, the searchAttr attribute is used instead.
             * 
             */
            "labelAttr": Object;
            set(property:"labelAttr", value: Object): void;
            get(property:"labelAttr"): Object;
            watch(property:"labelAttr", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Specifies how to interpret the labelAttr in the data store items.
             * Can be "html" or "text".
             * 
             */
            "labelType": string;
            set(property:"labelType", value: string): void;
            get(property:"labelType"): string;
            watch(property:"labelType", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The max height for our dropdown.
             * Any dropdown taller than this will have scrollbars.
             * Set to 0 for no max height, or -1 to limit height to available space in viewport
             * 
             */
            "maxHeight": number;
            set(property:"maxHeight", value: number): void;
            get(property:"maxHeight"): number;
            watch(property:"maxHeight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Argument to data provider.
             * Specifies maximum number of search results to return per query
             * 
             */
            "pageSize": number;
            set(property:"pageSize", value: number): void;
            get(property:"pageSize"): number;
            watch(property:"pageSize", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * This defines the regular expression used to validate the input.
             * Do not add leading ^ or $ characters since the widget adds these.
             * A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
             * set('pattern', String|Function).
             * 
             */
            "pattern": string;
            set(property:"pattern", value: string): void;
            get(property:"pattern"): string;
            watch(property:"pattern", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A query that can be passed to store to initially filter the items.
             * ComboBox overwrites any reference to the searchAttr and sets it to the queryExpr with the user's input substituted.
             * 
             */
            "query": Object;
            set(property:"query", value: Object): void;
            get(property:"query"): Object;
            watch(property:"query", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This specifies what query is sent to the data store,
             * based on what the user has typed.  Changing this expression will modify
             * whether the results are only exact matches, a "starting with" match,
             * etc.
             * ${0} will be substituted for the user text.
             * * is used for wildcards.
             * ${0}* means "starts with", *${0}* means "contains", ${0} means "is"
             * 
             */
            "queryExpr": string;
            set(property:"queryExpr", value: string): void;
            get(property:"queryExpr"): string;
            watch(property:"queryExpr", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Search for items in the data store where this attribute (in the item)
             * matches what the user typed
             * 
             */
            "searchAttr": string;
            set(property:"searchAttr", value: string): void;
            get(property:"searchAttr"): string;
            watch(property:"searchAttr", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Delay in milliseconds between when user types something and we start
             * searching based on that value
             * 
             */
            "searchDelay": number;
            set(property:"searchDelay", value: number): void;
            get(property:"searchDelay"): number;
            watch(property:"searchDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Reference to data provider object used by this ComboBox.
             * 
             * Should be dojo/store/api/Store, but dojo/data/api/Read supported
             * for backwards compatibility.
             * 
             */
            "store": Object;
            set(property:"store", value: Object): void;
            get(property:"store"): Object;
            watch(property:"store", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus: boolean): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Highlights the string entered by the user in the menu.  By default this
             * highlights the first occurrence found. Override this method
             * to implement your custom highlighting.
             * 
             * @param label             
             * @param find             
             */
            doHighlight(label: String, find: String): any;
            /**
             * Dropdown widget class used to select a date/time.
             * Subclasses should specify this.
             * 
             */
            dropDownClass(): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * Return an error message to show if appropriate
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Returns true if the dropdown exists and it's data is loaded.  This can
             * be overridden in order to force a call to loadDropDown().
             * 
             */
            isLoaded(): boolean;
            /**
             * Tests if value is valid.
             * Can override with your own routine in a subclass.
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): boolean};
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and then calls
             * the given callback.
             * 
             * @param loadCallback             
             */
            loadDropDown(loadCallback: Function): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Opens the dropdown for this widget.   To be called only when this.dropDown
             * has been created and is ready to display (ie, it's data is loaded).
             * 
             */
            openDropDown(): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Called by oninit, onblur, and onkeypress.
             * Show missing or invalid messages if appropriate, and highlight textbox field.
             * 
             * @param isFocused             
             */
            validate(isFocused: boolean): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Callback when a search completes.
             * 
             * @param results An array of items from the originating _SearchMixin's store.             
             * @param query A copy of the originating _SearchMixin's query property.             
             * @param options The additional parameters sent to the originating _SearchMixin's store, including: start, count, queryOptions.             
             */
            onSearch(results: Object, query: Object, options: Object): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/CurrencyTextBox.html
         *
         * A validating currency textbox
         * CurrencyTextBox is similar to dijit/form/NumberTextBox but has a few
         * extra features related to currency:
         * 
         * After specifying the currency type (american dollars, euros, etc.) it automatically
         *  sets parse/format options such as how many decimal places to show.
         * The currency mark (dollar sign, euro mark, etc.) is displayed when the field is blurred
         *  but erased during editing, so that the user can just enter a plain number.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class CurrencyTextBox extends dijit.form.NumberTextBox {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Despite the name, this parameter specifies both constraints on the input
             * (including minimum/maximum allowed values) as well as
             * formatting options.
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * the ISO4217 currency code, a three letter sequence like "USD"
             * 
             */
            "currency": string;
            set(property:"currency", value: string): void;
            get(property:"currency"): string;
            watch(property:"currency", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Properties to mix into constraints when the value is being edited.
             * This is here because we edit the number in the format "12345", which is
             * different than the display value (ex: "12,345")
             * 
             */
            "editOptions": Object;
            set(property:"editOptions", value: Object): void;
            get(property:"editOptions"): Object;
            watch(property:"editOptions", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This defines the regular expression used to validate the input.
             * Do not add leading ^ or $ characters since the widget adds these.
             * A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
             * set('pattern', String|Function).
             * 
             */
            "pattern": string;
            set(property:"pattern", value: string): void;
            get(property:"pattern"): string;
            watch(property:"pattern", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is out-of-range
             * 
             */
            "rangeMessage": string;
            set(property:"rangeMessage", value: string): void;
            get(property:"rangeMessage"): string;
            watch(property:"rangeMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Tests if the value is in the min/max range specified in constraints
             * 
             * @param isFocused             
             */
            isInRange(isFocused: boolean): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): boolean};
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Parses string value as a Currency, according to the constraints object
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Overridable function used to validate the range of the numeric input value.
             * 
             * @param primitive             
             * @param constraints             
             */
            rangeCheck(primitive: number, constraints: dijit.form.RangeBoundTextBox.__Constraints): boolean;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Overridable function used to convert the get('value') result to a canonical
             * (non-localized) string.  For example, will print dates in ISO format, and
             * numbers the same way as they are represented in javascript.
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): String;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/Form.html
         *
         * Widget corresponding to HTML form tag, for validation and serialization
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class Form extends dijit._Widget implements dijit._TemplatedMixin, dijit.form._FormMixin, dijit.layout._ContentPaneResizeMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * List of MIME types for file upload.
             * 
             */
            "accept": Object;
            set(property:"accept", value: Object): void;
            get(property:"accept"): Object;
            watch(property:"accept", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "accept-charset": string;
            set(property:"accept-charset", value: string): void;
            get(property:"accept-charset"): string;
            watch(property:"accept-charset", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Server-side form handler.
             * 
             */
            "action": Object;
            set(property:"action", value: Object): void;
            get(property:"action"): Object;
            watch(property:"action", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * 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;
            set(property:"doLayout", value: boolean): void;
            get(property:"doLayout"): boolean;
            watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Encoding type for the form, ex: application/x-www-form-urlencoded.
             * 
             */
            "encType": Object;
            set(property:"encType", value: Object): void;
            get(property:"encType"): Object;
            watch(property:"encType", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Indicates that this widget will call resize() on it's child widgets
             * when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTTP method used to submit the form, either "GET" or "POST".
             * 
             */
            "method": Object;
            set(property:"method", value: Object): void;
            get(property:"method"): Object;
            watch(property:"method", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Name of form for scripting.
             * 
             */
            "name": Object;
            set(property:"name", value: Object): void;
            get(property:"name"): Object;
            watch(property:"name", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Will be "Error" if one or more of the child widgets has an invalid value,
             * "Incomplete" if not all of the required child widgets are filled in.  Otherwise, "",
             * which indicates that the form is ready to be submitted.
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Target frame for the document to be opened in.
             * 
             */
            "target": Object;
            set(property:"target", value: Object): void;
            get(property:"target"): Object;
            watch(property:"target", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * You can call this function directly, ex. in the event that you
             * programmatically add a widget to the form after the form has been
             * initialized.
             * 
             * @param inStartup             
             */
            connectChildren(inStartup: boolean): void;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Deprecated method.   Applications no longer need to call this.   Remove for 2.0.
             * 
             */
            disconnectChildren(): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Deprecated: use submit()
             * 
             * @param formContents             
             */
            execute(formContents: Object): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * 
             */
            getValues(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Returns true if all of the widgets are valid.
             * Deprecated, will be removed in 2.0.  Use get("state") instead.
             * 
             */
            isValid: {(): boolean};
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * restores all widget values back to their init values,
             * calls onReset() which can cancel the reset by returning false
             * 
             * @param e               Optional            
             */
            reset(e?: Event): void;
            /**
             * See dijit/layout/_LayoutWidget.resize() for description.
             * Although ContentPane doesn't extend _LayoutWidget, it does implement
             * the same API.
             * 
             * @param changeSize             
             * @param resultSize             
             */
            resize(changeSize: any, resultSize: any): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             * @param val             
             */
            setValues(val: any): any;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * programmatically submit form if and only if the onSubmit returns true
             * 
             */
            submit(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * returns if the form is valid - same as isValid - but
             * provides a few additional (ui-specific) features:
             * 
             * it will highlight any sub-widgets that are not valid
             * it will call focus() on the first invalid sub-widget
             * 
             */
            validate(): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Deprecated: use onSubmit()
             * 
             */
            onExecute(): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Callback when user resets the form. This method is intended
             * to be over-ridden. When the reset method is called
             * programmatically, the return value from onReset is used
             * to compute whether or not resetting should proceed
             * 
             * @param e               Optional            
             */
            onReset(e: Event): boolean;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
            /**
             * Callback when user submits the form.
             * This method is intended to be over-ridden, but by default it checks and
             * returns the validity of form elements. When the submit
             * method is called programmatically, the return value from
             * onSubmit is used to compute whether or not submission
             * should proceed
             * 
             * @param e               Optional            
             */
            onSubmit(e: Event): any;
            /**
             * Stub function to connect to if you want to do something
             * (like disable/enable a submit button) when the valid
             * state changes on the form as a whole.
             * 
             * Deprecated.  Will be removed in 2.0.  Use watch("state", ...) instead.
             * 
             * @param isValid             
             */
            onValidStateChange(isValid: boolean): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/DropDownButton.html
         *
         * A button with a drop down
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class DropDownButton extends dijit.form.Button implements dijit._Container, dijit._HasDropDown {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down at least as wide as this
             * widget.  Set to false if the drop down should just be its
             * default width.
             * 
             */
            "autoWidth": boolean;
            set(property:"autoWidth", value: boolean): void;
            get(property:"autoWidth"): boolean;
            watch(property:"autoWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            set(property:"dropDown", value: Object): void;
            get(property:"dropDown"): Object;
            watch(property:"dropDown", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            set(property:"dropDownPosition", value: Object): void;
            get(property:"dropDownPosition"): Object;
            watch(property:"dropDownPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            set(property:"forceWidth", value: boolean): void;
            get(property:"forceWidth"): boolean;
            watch(property:"forceWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Class to apply to DOMNode in button to make it display an icon
             * 
             */
            "iconClass": string;
            set(property:"iconClass", value: string): void;
            get(property:"iconClass"): string;
            watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Content to display in button.
             * 
             */
            "label": string;
            set(property:"label", value: string): void;
            get(property:"label"): string;
            watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The max height for our dropdown.
             * Any dropdown taller than this will have scrollbars.
             * Set to 0 for no max height, or -1 to limit height to available space in viewport
             * 
             */
            "maxHeight": number;
            set(property:"maxHeight", value: number): void;
            get(property:"maxHeight"): number;
            watch(property:"maxHeight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this to true to hide the label text and display only the icon.
             * (If showLabel=false then iconClass must be specified.)
             * Especially useful for toolbars.
             * If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
             * 
             * The exception case is for computers in high-contrast mode, where the label
             * will still be displayed, since the icon doesn't appear.
             * 
             */
            "showLabel": boolean;
            set(property:"showLabel", value: boolean): void;
            get(property:"showLabel"): boolean;
            watch(property:"showLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus: boolean): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            isLoaded(): boolean;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * 
             * @param callback             
             */
            loadDropDown(callback: Function): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Opens the dropdown for this widget.   To be called only when this.dropDown
             * has been created and is ready to display (ie, it's data is loaded).
             * 
             */
            openDropDown(): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('label', ...) instead.
             * 
             * @param content             
             */
            setLabel(content: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): boolean;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/DateTextBox.html
         *
         * A validating, serializable, range-bound date text box with a drop down calendar
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree     
         */
        class DateTextBox extends dijit.form._DateTimeTextBox {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "autoWidth": boolean;
            set(property:"autoWidth", value: boolean): void;
            get(property:"autoWidth"): boolean;
            watch(property:"autoWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Despite the name, this parameter specifies both constraints on the input
             * (including starting/ending dates/times allowed) as well as
             * formatting options like whether the date is displayed in long (ex: December 25, 2005)
             * or short (ex: 12/25/2005) format.  See dijit/form/_DateTimeTextBox.__Constraints for details.
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * JavaScript namespace to find calendar routines.  If unspecified, uses Gregorian calendar routines
             * at dojo/date and dojo/date/locale.
             * 
             */
            "datePackage": string;
            set(property:"datePackage", value: string): void;
            get(property:"datePackage"): string;
            watch(property:"datePackage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            set(property:"dropDown", value: Object): void;
            get(property:"dropDown"): Object;
            watch(property:"dropDown", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The default value to focus in the popupClass widget when the textbox value is empty.
             * 
             */
            "dropDownDefaultValue": Date;
            set(property:"dropDownDefaultValue", value: Date): void;
            get(property:"dropDownDefaultValue"): Date;
            watch(property:"dropDownDefaultValue", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            set(property:"dropDownPosition", value: Object): void;
            get(property:"dropDownPosition"): Object;
            watch(property:"dropDownPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            set(property:"forceWidth", value: boolean): void;
            get(property:"forceWidth"): boolean;
            watch(property:"forceWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this textbox to display a down arrow button, to open the drop down list.
             * 
             */
            "hasDownArrow": boolean;
            set(property:"hasDownArrow", value: boolean): void;
            get(property:"hasDownArrow"): boolean;
            watch(property:"hasDownArrow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "maxHeight": number;
            set(property:"maxHeight", value: number): void;
            get(property:"maxHeight"): number;
            watch(property:"maxHeight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is out-of-range
             * 
             */
            "rangeMessage": string;
            set(property:"rangeMessage", value: string): void;
            get(property:"rangeMessage"): string;
            watch(property:"rangeMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The value of this widget as a JavaScript Date object, with only year/month/day specified.
             * If specified in markup, use the format specified in stamp.fromISOString.
             * set("value", ...) accepts either a Date object or a string.
             * 
             */
            "value": Date;
            set(property:"value", value: Date): void;
            get(property:"value"): Date;
            watch(property:"value", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus: boolean): void;
            /**
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: Date, val2: Date): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Formats the value as a Date, according to specified locale (second argument)
             * 
             * @param value             
             * @param constraints An object with the following properties:selector (String): choice of 'time','date' (default: date and time)formatLength (String): choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'datePattern (String): override pattern with this stringtimePattern (String): override pattern with this stringam (String): override strings for am in timespm (String): override strings for pm in timeslocale (String): override the locale used to determine formatting rulesfullYear (Boolean): (format only) use 4 digit years whenever 2 digit years are called forstrict (Boolean): (parse only) strict parsing, off by default            
             */
            format(value: Date, constraints: Object): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Tests if the value is in the min/max range specified in constraints
             * 
             * @param isFocused             
             */
            isInRange(isFocused: boolean): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Returns true if the dropdown exists and it's data is loaded.  This can
             * be overridden in order to force a call to loadDropDown().
             * 
             */
            isLoaded(): boolean;
            /**
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): any};
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and then calls
             * the given callback.
             * 
             * @param loadCallback             
             */
            loadDropDown(loadCallback: Function): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * 
             * @param callback             
             */
            openDropDown(callback: Function): void;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Parses as string as a Date, according to constraints
             * 
             * @param value             
             * @param constraints An object with the following properties:selector (String): choice of 'time','date' (default: date and time)formatLength (String): choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'datePattern (String): override pattern with this stringtimePattern (String): override pattern with this stringam (String): override strings for am in timespm (String): override strings for pm in timeslocale (String): override the locale used to determine formatting rulesfullYear (Boolean): (format only) use 4 digit years whenever 2 digit years are called forstrict (Boolean): (parse only) strict parsing, off by default            
             */
            parse(value: String, constraints: Object): any;
            /**
             * Builds the regular needed to parse a localized date
             * 
             * @param options               OptionalAn object with the following properties:selector (String): choice of 'time','date' (default: date and time)formatLength (String): choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'datePattern (String): override pattern with this stringtimePattern (String): override pattern with this stringam (String): override strings for am in timespm (String): override strings for pm in timeslocale (String): override the locale used to determine formatting rulesfullYear (Boolean): (format only) use 4 digit years whenever 2 digit years are called forstrict (Boolean): (parse only) strict parsing, off by default            
             */
            pattern: {(options: Object): any};
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;

            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Overridable function used to validate the range of the numeric input value.
             * 
             * @param primitive             
             * @param constraints             
             */
            rangeCheck(primitive: number, constraints: dijit.form.RangeBoundTextBox.__Constraints): boolean;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): any;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/HorizontalRule.html
         *
         * Hash marks for dijit/form/HorizontalSlider
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class HorizontalRule extends dijit._Widget implements dijit._TemplatedMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * For HorizontalSlider, this is either "topDecoration" or "bottomDecoration",
             * and indicates whether this rule goes above or below the slider.
             * 
             */
            "container": string;
            set(property:"container", value: string): void;
            get(property:"container"): string;
            watch(property:"container", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Number of hash marks to generate
             * 
             */
            "count": number;
            set(property:"count", value: number): void;
            get(property:"count"): number;
            watch(property:"count", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * CSS style to apply to individual hash marks
             * 
             */
            "ruleStyle": string;
            set(property:"ruleStyle", value: string): void;
            get(property:"ruleStyle"): string;
            watch(property:"ruleStyle", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/FilteringSelect.html
         *
         * An enhanced version of the HTML SELECT tag, populated dynamically
         * An enhanced version of the HTML SELECT tag, populated dynamically. It works
         * very nicely with very large data sets because it can load and page data as needed.
         * It also resembles ComboBox, but does not allow values outside of the provided ones.
         * If OPTION tags are used as the data provider via markup, then the
         * OPTION tag's child text node is used as the displayed value when selected
         * while the OPTION tag's value attribute is used as the widget value on form submit.
         * To set the default value when using OPTION tags, specify the selected
         * attribute on 1 of the child OPTION tags.
         * 
         * Similar features:
         * 
         * There is a drop down list of possible values.
         * You can only enter a value from the drop down list.  (You can't
         *   enter an arbitrary value.)
         * The value submitted with the form is the hidden value (ex: CA),
         *   not the displayed value a.k.a. label (ex: California)
         * Enhancements over plain HTML version:
         * 
         * If you type in some text then it will filter down the list of
         *   possible values in the drop down list.
         * List can be specified either as a static list or via a javascript
         *   function (that can get the list from a server)
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class FilteringSelect extends dijit.form.MappedTextBox implements dijit.form.ComboBoxMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * If user types in a partial string, and then tab out of the <input> box,
             * automatically copy the first entry displayed in the drop down list to
             * the <input> field
             * 
             */
            "autoComplete": boolean;
            set(property:"autoComplete", value: boolean): void;
            get(property:"autoComplete"): boolean;
            watch(property:"autoComplete", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down at least as wide as this
             * widget.  Set to false if the drop down should just be its
             * default width.
             * 
             */
            "autoWidth": boolean;
            set(property:"autoWidth", value: boolean): void;
            get(property:"autoWidth"): boolean;
            watch(property:"autoWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * user-defined object needed to pass parameters to the validator functions
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            set(property:"dropDown", value: Object): void;
            get(property:"dropDown"): Object;
            watch(property:"dropDown", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            set(property:"dropDownPosition", value: Object): void;
            get(property:"dropDownPosition"): Object;
            watch(property:"dropDownPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Mixin to the store's fetch.
             * For example, to set the sort order of the ComboBox menu, pass:
             * 
             * { sort: [{attribute:"name",descending: true}] }
             * To override the default queryOptions so that deep=false, do:
             * 
             * { queryOptions: {ignoreCase: true, deep: false} }
             * 
             */
            "fetchProperties": Object;
            set(property:"fetchProperties", value: Object): void;
            get(property:"fetchProperties"): Object;
            watch(property:"fetchProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            set(property:"forceWidth", value: boolean): void;
            get(property:"forceWidth"): boolean;
            watch(property:"forceWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this textbox to have a down arrow button, to display the drop down list.
             * Defaults to true.
             * 
             */
            "hasDownArrow": boolean;
            set(property:"hasDownArrow", value: boolean): void;
            get(property:"hasDownArrow"): boolean;
            watch(property:"hasDownArrow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * One of: "first", "all" or "none".
             * 
             * If the ComboBox/FilteringSelect opens with the search results and the searched
             * string can be found, it will be highlighted.  If set to "all"
             * then will probably want to change queryExpr parameter to '${0}'
             * 
             * Highlighting is only performed when labelType is "text", so as to not
             * interfere with any HTML markup an HTML label might contain.
             * 
             */
            "highlightMatch": string;
            set(property:"highlightMatch", value: string): void;
            get(property:"highlightMatch"): string;
            watch(property:"highlightMatch", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Set true if the query should ignore case when matching possible items
             * 
             */
            "ignoreCase": boolean;
            set(property:"ignoreCase", value: boolean): void;
            get(property:"ignoreCase"): boolean;
            watch(property:"ignoreCase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is the item returned by the dojo/store/api/Store implementation that
             * provides the data for this ComboBox, it's the currently selected item.
             * 
             */
            "item": Object;
            set(property:"item", value: Object): void;
            get(property:"item"): Object;
            watch(property:"item", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The entries in the drop down list come from this attribute in the
             * dojo.data items.
             * If not specified, the searchAttr attribute is used instead.
             * 
             */
            "labelAttr": Object;
            set(property:"labelAttr", value: Object): void;
            get(property:"labelAttr"): Object;
            watch(property:"labelAttr", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Specifies how to interpret the labelAttr in the data store items.
             * Can be "html" or "text".
             * 
             */
            "labelType": string;
            set(property:"labelType", value: string): void;
            get(property:"labelType"): string;
            watch(property:"labelType", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The max height for our dropdown.
             * Any dropdown taller than this will have scrollbars.
             * Set to 0 for no max height, or -1 to limit height to available space in viewport
             * 
             */
            "maxHeight": number;
            set(property:"maxHeight", value: number): void;
            get(property:"maxHeight"): number;
            watch(property:"maxHeight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Argument to data provider.
             * Specifies maximum number of search results to return per query
             * 
             */
            "pageSize": number;
            set(property:"pageSize", value: number): void;
            get(property:"pageSize"): number;
            watch(property:"pageSize", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * This defines the regular expression used to validate the input.
             * Do not add leading ^ or $ characters since the widget adds these.
             * A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
             * set('pattern', String|Function).
             * 
             */
            "pattern": string;
            set(property:"pattern", value: string): void;
            get(property:"pattern"): string;
            watch(property:"pattern", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A query that can be passed to store to initially filter the items.
             * ComboBox overwrites any reference to the searchAttr and sets it to the queryExpr with the user's input substituted.
             * 
             */
            "query": Object;
            set(property:"query", value: Object): void;
            get(property:"query"): Object;
            watch(property:"query", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This specifies what query is sent to the data store,
             * based on what the user has typed.  Changing this expression will modify
             * whether the results are only exact matches, a "starting with" match,
             * etc.
             * ${0} will be substituted for the user text.
             * * is used for wildcards.
             * ${0}* means "starts with", *${0}* means "contains", ${0} means "is"
             * 
             */
            "queryExpr": string;
            set(property:"queryExpr", value: string): void;
            get(property:"queryExpr"): string;
            watch(property:"queryExpr", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * True (default) if user is required to enter a value into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Search for items in the data store where this attribute (in the item)
             * matches what the user typed
             * 
             */
            "searchAttr": string;
            set(property:"searchAttr", value: string): void;
            get(property:"searchAttr"): string;
            watch(property:"searchAttr", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Delay in milliseconds between when user types something and we start
             * searching based on that value
             * 
             */
            "searchDelay": number;
            set(property:"searchDelay", value: number): void;
            get(property:"searchDelay"): number;
            watch(property:"searchDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Reference to data provider object used by this ComboBox.
             * 
             * Should be dojo/store/api/Store, but dojo/data/api/Read supported
             * for backwards compatibility.
             * 
             */
            "store": Object;
            set(property:"store", value: Object): void;
            get(property:"store"): Object;
            watch(property:"store", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus: boolean): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Highlights the string entered by the user in the menu.  By default this
             * highlights the first occurrence found. Override this method
             * to implement your custom highlighting.
             * 
             * @param label             
             * @param find             
             */
            doHighlight(label: String, find: String): any;
            /**
             * Dropdown widget class used to select a date/time.
             * Subclasses should specify this.
             * 
             */
            dropDownClass(): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * Return an error message to show if appropriate
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Returns true if the dropdown exists and it's data is loaded.  This can
             * be overridden in order to force a call to loadDropDown().
             * 
             */
            isLoaded(): boolean;
            /**
             * 
             */
            isValid: {(): boolean};
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and then calls
             * the given callback.
             * 
             * @param loadCallback             
             */
            loadDropDown(loadCallback: Function): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Opens the dropdown for this widget.   To be called only when this.dropDown
             * has been created and is ready to display (ie, it's data is loaded).
             * 
             */
            openDropDown(): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Overridable function used to convert the get('value') result to a canonical
             * (non-localized) string.  For example, will print dates in ISO format, and
             * numbers the same way as they are represented in javascript.
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): String;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Callback when a search completes.
             * 
             * @param results An array of items from the originating _SearchMixin's store.             
             * @param query A copy of the originating _SearchMixin's query property.             
             * @param options The additional parameters sent to the originating _SearchMixin's store, including: start, count, queryOptions.             
             */
            onSearch(results: Object, query: Object, options: Object): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/HorizontalRuleLabels.html
         *
         * Labels for dijit/form/HorizontalSlider
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class HorizontalRuleLabels extends dijit.form.HorizontalRule {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * pattern, places, lang, et al (see dojo.number) for generated numeric labels when labels[] are not specified
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * For HorizontalSlider, this is either "topDecoration" or "bottomDecoration",
             * and indicates whether this rule goes above or below the slider.
             * 
             */
            "container": string;
            set(property:"container", value: string): void;
            get(property:"container"): string;
            watch(property:"container", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Number of hash marks to generate
             * 
             */
            "count": number;
            set(property:"count", value: number): void;
            get(property:"count"): number;
            watch(property:"count", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Array of text labels to render - evenly spaced from left-to-right or bottom-to-top.
             * Alternately, minimum and maximum can be specified, to get numeric labels.
             * 
             */
            "labels": Object;
            set(property:"labels", value: Object): void;
            get(property:"labels"): Object;
            watch(property:"labels", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * CSS style to apply to individual text labels
             * 
             */
            "labelStyle": string;
            set(property:"labelStyle", value: string): void;
            get(property:"labelStyle"): string;
            watch(property:"labelStyle", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "maximum": number;
            set(property:"maximum", value: number): void;
            get(property:"maximum"): number;
            watch(property:"maximum", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * 
             */
            "minimum": number;
            set(property:"minimum", value: number): void;
            get(property:"minimum"): number;
            watch(property:"minimum", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Number of generated numeric labels that should be rendered as '' on the ends when labels[] are not specified
             * 
             */
            "numericMargin": number;
            set(property:"numericMargin", value: number): void;
            get(property:"numericMargin"): number;
            watch(property:"numericMargin", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * CSS style to apply to individual hash marks
             * 
             */
            "ruleStyle": string;
            set(property:"ruleStyle", value: string): void;
            get(property:"ruleStyle"): string;
            watch(property:"ruleStyle", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Overridable function to return array of labels to use for this slider.
             * Can specify a getLabels() method instead of a labels[] array, or min/max attributes.
             * 
             */
            getLabels(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/MappedTextBox.html
         *
         * A dijit/form/ValidationTextBox subclass which provides a base class for widgets that have
         * a visible formatted display value, and a serializable
         * value in a hidden input field which is actually sent to the server.
         * The visible display may
         * be locale-dependent and interactive.  The value sent to the server is stored in a hidden
         * input field which uses the name attribute declared by the original widget.  That value sent
         * to the server is defined by the dijit/form/MappedTextBox.serialize() method and is typically
         * locale-neutral.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class MappedTextBox extends dijit.form.ValidationTextBox {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * user-defined object needed to pass parameters to the validator functions
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This defines the regular expression used to validate the input.
             * Do not add leading ^ or $ characters since the widget adds these.
             * A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
             * set('pattern', String|Function).
             * 
             */
            "pattern": string;
            set(property:"pattern", value: string): void;
            get(property:"pattern"): string;
            watch(property:"pattern", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": Object;
            set(property:"value", value: Object): void;
            get(property:"value"): Object;
            watch(property:"value", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * Return an error message to show if appropriate
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Tests if value is valid.
             * Can override with your own routine in a subclass.
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): any};
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints?: Object): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Overridable function used to convert the get('value') result to a canonical
             * (non-localized) string.  For example, will print dates in ISO format, and
             * numbers the same way as they are represented in javascript.
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): String;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/MultiSelect.html
         *
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class MultiSelect extends dijit.form._FormValueWidget {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "multiple": boolean;
            set(property:"multiple", value: boolean): void;
            get(property:"multiple"): boolean;
            watch(property:"multiple", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Number of elements to display on a page
             * NOTE: may be removed in version 2.0, since elements may have variable height;
             * set the size via style="..." or CSS class names instead.
             * 
             */
            "size": number;
            set(property:"size", value: number): void;
            get(property:"size"): number;
            watch(property:"size", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * @param select             
             */
            addSelected(select: dijit.form.MultiSelect): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Access the NodeList of the selected options directly
             * 
             */
            getSelected(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Invert the selection
             * 
             * @param onChange               OptionalIf false, onChange is not fired.             
             */
            invertSelection(onChange: boolean): void;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * 
             * @param size             
             */
            resize(size: Object): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/HorizontalSlider.html
         *
         * A form widget that allows one to select a value with a horizontally draggable handle
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class HorizontalSlider extends dijit.form._FormValueWidget implements dijit._Container {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If clicking the slider bar changes the value or not
             * 
             */
            "clickSelect": boolean;
            set(property:"clickSelect", value: boolean): void;
            get(property:"clickSelect"): boolean;
            watch(property:"clickSelect", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If specified, indicates that the slider handle has only 'discreteValues' possible positions,
             * and that after dragging the handle, it will snap to the nearest possible position.
             * Thus, the slider has only 'discreteValues' possible values.
             * 
             * For example, if minimum=10, maxiumum=30, and discreteValues=3, then the slider handle has
             * three possible positions, representing values 10, 20, or 30.
             * 
             * If discreteValues is not specified or if it's value is higher than the number of pixels
             * in the slider bar, then the slider handle can be moved freely, and the slider's value will be
             * computed/reported based on pixel position (in this case it will likely be fractional,
             * such as 123.456789).
             * 
             */
            "discreteValues": number;
            set(property:"discreteValues", value: number): void;
            get(property:"discreteValues"): number;
            watch(property:"discreteValues", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The maximum value the slider can be set to.
             * 
             */
            "maximum": number;
            set(property:"maximum", value: number): void;
            get(property:"maximum"): number;
            watch(property:"maximum", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The minimum value the slider can be set to.
             * 
             */
            "minimum": number;
            set(property:"minimum", value: number): void;
            get(property:"minimum"): number;
            watch(property:"minimum", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * If discreteValues is also specified, this indicates the amount of clicks (ie, snap positions)
             * that the slider handle is moved via pageup/pagedown keys.
             * If discreteValues is not specified, it indicates the number of pixels.
             * 
             */
            "pageIncrement": number;
            set(property:"pageIncrement", value: number): void;
            get(property:"pageIncrement"): number;
            watch(property:"pageIncrement", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Show increment/decrement buttons at the ends of the slider?
             * 
             */
            "showButtons": boolean;
            set(property:"showButtons", value: boolean): void;
            get(property:"showButtons"): boolean;
            watch(property:"showButtons", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The time in ms to take to animate the slider handle from 0% to 100%,
             * when clicking the slider bar to make the handle move.
             * 
             */
            "slideDuration": number;
            set(property:"slideDuration", value: number): void;
            get(property:"slideDuration"): number;
            watch(property:"slideDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "value": number;
            set(property:"value", value: number): void;
            get(property:"value"): number;
            watch(property:"value", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module HorizontalSlider {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/HorizontalSlider._Mover.html
             *
             * 
             * @param node a node (or node's id) to be moved     
             * @param e a mouse event, which started the move;only pageX and pageY properties are used     
             * @param host       Optionalobject which implements the functionality of the move,and defines proper events (onMoveStart and onMoveStop)     
             */
            class _Mover extends dojo.dnd.Mover {
                constructor(node: HTMLElement, e: Event, host?: Object);
                /**
                 * 
                 * @param e             
                 */
                destroy(e?: any): void;
                /**
                 * 
                 * @param type             
                 * @param event             
                 */
                emit(type: any, event: any): any;
                /**
                 * 
                 * @param type             
                 * @param listener             
                 */
                on(type: any, listener: any): any;
                /**
                 * makes the node absolute; it is meant to be called only once.
                 * relative and absolutely positioned nodes are assumed to use pixel units
                 * 
                 * @param e             
                 */
                onFirstMove(e: any): void;
                /**
                 * 
                 * @param e             
                 */
                onMouseMove(e: any): void;
                /**
                 * 
                 * @param e             
                 */
                onMouseUp(e: any): void;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/NumberTextBox.html
         *
         * A TextBox for entering numbers, with formatting and range checking
         * NumberTextBox is a textbox for entering and displaying numbers, supporting
         * the following main features:
         * 
         * Enforce minimum/maximum allowed values (as well as enforcing that the user types
         *  a number rather than a random string)
         * NLS support (altering roles of comma and dot as "thousands-separator" and "decimal-point"
         *  depending on locale).
         * Separate modes for editing the value and displaying it, specifically that
         *  the thousands separator character (typically comma) disappears when editing
         *  but reappears after the field is blurred.
         * Formatting and constraints regarding the number of places (digits after the decimal point)
         *  allowed on input, and number of places displayed when blurred (see constraints parameter).
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class NumberTextBox extends dijit.form.RangeBoundTextBox {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Properties to mix into constraints when the value is being edited.
             * This is here because we edit the number in the format "12345", which is
             * different than the display value (ex: "12,345")
             * 
             */
            "editOptions": Object;
            set(property:"editOptions", value: Object): void;
            get(property:"editOptions"): Object;
            watch(property:"editOptions", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "isValid": any;
            set(property:"isValid", value: any): void;
            get(property:"isValid"): any;
            watch(property:"isValid", callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This defines the regular expression used to validate the input.
             * Do not add leading ^ or $ characters since the widget adds these.
             * A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
             * set('pattern', String|Function).
             * 
             */
            "pattern": string;
            set(property:"pattern", value: string): void;
            get(property:"pattern"): string;
            watch(property:"pattern", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is out-of-range
             * 
             */
            "rangeMessage": string;
            set(property:"rangeMessage", value: string): void;
            get(property:"rangeMessage"): string;
            watch(property:"rangeMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Tests if the value is in the min/max range specified in constraints
             * 
             * @param isFocused             
             */
            isInRange(isFocused: boolean): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            Mixin(): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Overridable function used to validate the range of the numeric input value.
             * 
             * @param primitive             
             * @param constraints             
             */
            rangeCheck(primitive: number, constraints: dijit.form.RangeBoundTextBox.__Constraints): boolean;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Overridable function used to convert the get('value') result to a canonical
             * (non-localized) string.  For example, will print dates in ISO format, and
             * numbers the same way as they are represented in javascript.
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): String;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module NumberTextBox {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/NumberTextBox.__Constraints.html
             *
             * Specifies both the rules on valid/invalid values (minimum, maximum,
             * number of required decimal places), and also formatting options for
             * displaying the value when the field is not focused.
             * 
             */
            class __Constraints {
                constructor();
                /**
                 * If false, show no decimal places, overriding places and pattern settings.
                 * 
                 */
                "fractional": boolean;
                /**
                 * override the locale used to determine formatting rules
                 * 
                 */
                "locale": string;
                /**
                 * Maximum signed value.  Default is +Infinity
                 * 
                 */
                "max": number;
                /**
                 * Minimum signed value.  Default is -Infinity
                 * 
                 */
                "min": number;
                /**
                 * override formatting pattern
                 * with this string.  Default value is based on locale.  Overriding this property will defeat
                 * localization.  Literal characters in patterns are not supported.
                 * 
                 */
                "pattern": string;
                /**
                 * fixed number of decimal places to show.  This overrides any
                 * information in the provided pattern.
                 * 
                 */
                "places": number;
                /**
                 * 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1
                 * means do not round.
                 * 
                 */
                "round": number;
                /**
                 * strict parsing, false by default.  Strict parsing requires input as produced by the format() method.
                 * Non-strict is more permissive, e.g. flexible on white space, omitting thousands separators
                 * 
                 */
                "strict": boolean;
                /**
                 * choose a format type based on the locale from the following:
                 * decimal, scientific (not yet supported), percent, currency. decimal by default.
                 * 
                 */
                "type": string;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/NumberTextBox.Mixin.html
             *
             * A mixin for all number textboxes
             * 
             */
            class Mixin {
                constructor();
                /**
                 * Despite the name, this parameter specifies both constraints on the input
                 * (including minimum/maximum allowed values) as well as
                 * formatting options like places (the number of digits to display after
                 * the decimal point).
                 * 
                 */
                "constraints": Object;
                /**
                 * Properties to mix into constraints when the value is being edited.
                 * This is here because we edit the number in the format "12345", which is
                 * different than the display value (ex: "12,345")
                 * 
                 */
                "editOptions": Object;
                /**
                 * The value of this NumberTextBox as a Javascript Number (i.e., not a String).
                 * If the displayed value is blank, the value is NaN, and if the user types in
                 * an gibberish value (like "hello world"), the value is undefined
                 * (i.e. get('value') returns undefined).
                 * 
                 * Symmetrically, set('value', NaN) will clear the displayed value,
                 * whereas set('value', undefined) will have no effect.
                 * 
                 */
                "value": number;
                /**
                 * This is called with both the display value (string), and the actual value (a number).
                 * When called with the actual value it does corrections so that '' etc. are represented as NaN.
                 * Otherwise it dispatches to the superclass's filter() method.
                 * 
                 * See dijit/form/TextBox.filter() for more details.
                 * 
                 * @param value             
                 */
                filter(value: number): number;
                /**
                 * Formats the value as a Number, according to constraints.
                 * 
                 * @param value             
                 * @param constraints An object with the following properties:pattern (String, optional): override formatting patternwith this string.  Default value is based on locale.  Overriding this property will defeatlocalization.  Literal characters in patterns are not supported.type (String, optional): choose a format type based on the locale from the following:decimal, scientific (not yet supported), percent, currency. decimal by default.places (Number, optional): fixed number of decimal places to show.  This overrides anyinformation in the provided pattern.round (Number, optional): 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1means do not round.locale (String, optional): override the locale used to determine formatting rulesfractional (Boolean, optional): If false, show no decimal places, overriding places and pattern settings.            
                 */
                format(value: number, constraints: Object): any;
                /**
                 * 
                 * @param isFocused             
                 */
                isValid: {(isFocused: boolean): any};
                /**
                 * Replaceable function to convert a formatted string to a number value
                 * 
                 * @param value             
                 * @param constraints An object with the following properties:pattern (String, optional): override formatting patternwith this string.  Default value is based on locale.  Overriding this property will defeatlocalization.  Literal characters in patterns are not supported.type (String, optional): choose a format type based on the locale from the following:decimal, scientific (not yet supported), percent, currency. decimal by default.places (Number, optional): fixed number of decimal places to show.  This overrides anyinformation in the provided pattern.round (Number, optional): 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1means do not round.locale (String, optional): override the locale used to determine formatting rulesfractional (Boolean, optional): If false, show no decimal places, overriding places and pattern settings.            
                 */
                parse(value: String, constraints: Object): any;
                /**
                 * 
                 * @param constraints             
                 */
                pattern(constraints: any): String;
                /**
                 * 
                 */
                postMixInProperties(): void;
                /**
                 * Convert value (a Number) into a canonical string (ie, how the number literal is written in javascript/java/C/etc.)
                 * 
                 * @param value             
                 * @param options               Optional            
                 */
                serialize(value: number, options: Object): String;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/NumberSpinner.html
         *
         * Extends NumberTextBox to add up/down arrows and pageup/pagedown for incremental change to the value
         * A dijit/form/NumberTextBox extension to provide keyboard accessible value selection
         * as well as icons for spinning direction. When using the keyboard, the typematic rules
         * apply, meaning holding the key will gradually increase or decrease the value and
         * accelerate.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class NumberSpinner extends dijit.form._Spinner {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Number of milliseconds before a held arrow key or up/down button becomes typematic
             * 
             */
            "defaultTimeout": number;
            set(property:"defaultTimeout", value: number): void;
            get(property:"defaultTimeout"): number;
            watch(property:"defaultTimeout", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Properties to mix into constraints when the value is being edited.
             * This is here because we edit the number in the format "12345", which is
             * different than the display value (ex: "12,345")
             * 
             */
            "editOptions": Object;
            set(property:"editOptions", value: Object): void;
            get(property:"editOptions"): Object;
            watch(property:"editOptions", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Adjust the value by this much when spinning using the PgUp/Dn keys
             * 
             */
            "largeDelta": number;
            set(property:"largeDelta", value: number): void;
            get(property:"largeDelta"): number;
            watch(property:"largeDelta", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * minimum number of milliseconds that typematic event fires when held key or button is held
             * 
             */
            "minimumTimeout": number;
            set(property:"minimumTimeout", value: number): void;
            get(property:"minimumTimeout"): number;
            watch(property:"minimumTimeout", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This defines the regular expression used to validate the input.
             * Do not add leading ^ or $ characters since the widget adds these.
             * A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
             * set('pattern', String|Function).
             * 
             */
            "pattern": string;
            set(property:"pattern", value: string): void;
            get(property:"pattern"): string;
            watch(property:"pattern", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is out-of-range
             * 
             */
            "rangeMessage": string;
            set(property:"rangeMessage", value: string): void;
            get(property:"rangeMessage"): string;
            watch(property:"rangeMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Adjust the value by this much when spinning using the arrow keys/buttons
             * 
             */
            "smallDelta": number;
            set(property:"smallDelta", value: number): void;
            get(property:"smallDelta"): number;
            watch(property:"smallDelta", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fraction of time used to change the typematic timer between events.
             * 1.0 means that each typematic event fires at defaultTimeout intervals.
             * Less than 1.0 means that each typematic event fires at an increasing faster rate.
             * 
             */
            "timeoutChangeRate": number;
            set(property:"timeoutChangeRate", value: number): void;
            get(property:"timeoutChangeRate"): number;
            watch(property:"timeoutChangeRate", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Change Number val by the given amount
             * 
             * @param val             
             * @param delta             
             */
            adjust(val: Object, delta: number): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Tests if the value is in the min/max range specified in constraints
             * 
             * @param isFocused             
             */
            isInRange(isFocused: boolean): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): any};
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Overridable function used to validate the range of the numeric input value.
             * 
             * @param primitive             
             * @param constraints             
             */
            rangeCheck(primitive: number, constraints: dijit.form.RangeBoundTextBox.__Constraints): boolean;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Overridable function used to convert the get('value') result to a canonical
             * (non-localized) string.  For example, will print dates in ISO format, and
             * numbers the same way as they are represented in javascript.
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): String;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/RadioButton.html
         *
         * Same as an HTML radio, but with fancy styling.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class RadioButton extends dijit.form.CheckBox implements dijit.form._RadioButtonMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * In markup, specified as "checked='checked'" or just "checked".
             * True if the button is depressed, or the checkbox is checked,
             * or the radio button is selected, etc.
             * 
             */
            "checked": boolean;
            set(property:"checked", value: boolean): void;
            get(property:"checked"): boolean;
            watch(property:"checked", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Class to apply to DOMNode in button to make it display an icon
             * 
             */
            "iconClass": string;
            set(property:"iconClass", value: string): void;
            get(property:"iconClass"): string;
            watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Content to display in button.
             * 
             */
            "label": string;
            set(property:"label", value: string): void;
            get(property:"label"): string;
            watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this to true to hide the label text and display only the icon.
             * (If showLabel=false then iconClass must be specified.)
             * Especially useful for toolbars.
             * If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
             * 
             * The exception case is for computers in high-contrast mode, where the label
             * will still be displayed, since the icon doesn't appear.
             * 
             */
            "showLabel": boolean;
            set(property:"showLabel", value: boolean): void;
            get(property:"showLabel"): boolean;
            watch(property:"showLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('checked', true/false) instead.
             * 
             * @param checked             
             */
            setChecked(checked: boolean): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('label', ...) instead.
             * 
             * @param content             
             */
            setLabel(content: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: Event): boolean;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/SimpleTextarea.html
         *
         * A simple textarea that degrades, and responds to
         * minimal LayoutContainer usage, and works with dijit/form/Form.
         * Doesn't automatically size according to input, like Textarea.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class SimpleTextarea extends dijit.form.TextBox {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "cols": string;
            set(property:"cols", value: string): void;
            get(property:"cols"): string;
            watch(property:"cols", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The number of rows of text.
             * 
             */
            "rows": number;
            set(property:"rows", value: number): void;
            get(property:"rows"): number;
            watch(property:"rows", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * 
             * @param value             
             */
            filter(value: String): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/RangeBoundTextBox.html
         *
         * Base class for textbox form widgets which defines a range of valid values.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class RangeBoundTextBox extends dijit.form.MappedTextBox {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This defines the regular expression used to validate the input.
             * Do not add leading ^ or $ characters since the widget adds these.
             * A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
             * set('pattern', String|Function).
             * 
             */
            "pattern": any;
            set(property:"pattern", value: any): void;
            get(property:"pattern"): any;
            watch(property:"pattern", callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is out-of-range
             * 
             */
            "rangeMessage": string;
            set(property:"rangeMessage", value: string): void;
            get(property:"rangeMessage"): string;
            watch(property:"rangeMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": Object;
            set(property:"value", value: Object): void;
            get(property:"value"): Object;
            watch(property:"value", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: Object, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Tests if the value is in the min/max range specified in constraints
             * 
             * @param isFocused             
             */
            isInRange(isFocused: boolean): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): any};
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Overridable function used to validate the range of the numeric input value.
             * 
             * @param primitive             
             * @param constraints             
             */
            rangeCheck(primitive: number, constraints: dijit.form.RangeBoundTextBox.__Constraints): boolean;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Overridable function used to convert the get('value') result to a canonical
             * (non-localized) string.  For example, will print dates in ISO format, and
             * numbers the same way as they are represented in javascript.
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): String;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module RangeBoundTextBox {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/RangeBoundTextBox.__Constraints.html
             *
             * 
             */
            class __Constraints {
                constructor();
                /**
                 * Maximum signed value.  Default is +Infinity
                 * 
                 */
                "max": number;
                /**
                 * Minimum signed value.  Default is -Infinity
                 * 
                 */
                "min": number;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/Textarea.html
         *
         * A textarea widget that adjusts it's height according to the amount of data.
         * A textarea that dynamically expands/contracts (changing it's height) as
         * the user types, to display all the text without requiring a scroll bar.
         * 
         * Takes nearly all the parameters (name, value, etc.) that a vanilla textarea takes.
         * Rows is not supported since this widget adjusts the height.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class Textarea extends dijit.form.SimpleTextarea implements dijit.form._ExpandingTextAreaMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "cols": string;
            set(property:"cols", value: string): void;
            get(property:"cols"): string;
            watch(property:"cols", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The number of rows of text.
             * 
             */
            "rows": number;
            set(property:"rows", value: number): void;
            get(property:"rows"): number;
            watch(property:"rows", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * 
             * @param value             
             */
            filter(value: String): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Resizes the textarea vertically (should be called after a style/value change)
             * 
             */
            resize(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/Select.html
         *
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree     
         */
        class Select extends dijit.form._FormSelectWidget implements dijit._HasDropDown, dijit._KeyNavMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down at least as wide as this
             * widget.  Set to false if the drop down should just be its
             * default width.
             * 
             */
            "autoWidth": boolean;
            set(property:"autoWidth", value: boolean): void;
            get(property:"autoWidth"): boolean;
            watch(property:"autoWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            set(property:"dropDown", value: Object): void;
            get(property:"dropDown"): Object;
            watch(property:"dropDown", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            set(property:"dropDownPosition", value: Object): void;
            get(property:"dropDownPosition"): Object;
            watch(property:"dropDownPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * What to display in an "empty" dropdown
             * 
             */
            "emptyLabel": string;
            set(property:"emptyLabel", value: string): void;
            get(property:"emptyLabel"): string;
            watch(property:"emptyLabel", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The currently focused child widget, or null if there isn't one
             * 
             */
            "focusedChild": Object;
            set(property:"focusedChild", value: Object): void;
            get(property:"focusedChild"): Object;
            watch(property:"focusedChild", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            set(property:"forceWidth", value: boolean): void;
            get(property:"forceWidth"): boolean;
            watch(property:"forceWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The entries in the drop down list come from this attribute in the dojo.store items.
             * If store is set, labelAttr must be set too, unless store is an old-style
             * dojo.data store rather than a new dojo/store.
             * 
             */
            "labelAttr": Object;
            set(property:"labelAttr", value: Object): void;
            get(property:"labelAttr"): Object;
            watch(property:"labelAttr", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * By default loadChildren is called when the items are fetched from the
             * store.  This property allows delaying loadChildren (and the creation
             * of the options/menuitems) until the user clicks the button to open the
             * dropdown.
             * 
             */
            "loadChildrenOnOpen": boolean;
            set(property:"loadChildrenOnOpen", value: boolean): void;
            get(property:"loadChildrenOnOpen"): boolean;
            watch(property:"loadChildrenOnOpen", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The max height for our dropdown.
             * Any dropdown taller than this will have scrollbars.
             * Set to 0 for no max height, or -1 to limit height to available space in viewport
             * 
             */
            "maxHeight": number;
            set(property:"maxHeight", value: number): void;
            get(property:"maxHeight"): number;
            watch(property:"maxHeight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Currently displayed error/prompt message
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If multiple characters are typed where each keystroke happens within
             * multiCharSearchDuration of the previous keystroke,
             * search for nodes matching all the keystrokes.
             * 
             * For example, typing "ab" will search for entries starting with
             * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
             * 
             */
            "multiCharSearchDuration": number;
            set(property:"multiCharSearchDuration", value: number): void;
            get(property:"multiCharSearchDuration"): number;
            watch(property:"multiCharSearchDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Whether or not we are multi-valued
             * 
             */
            "multiple": boolean;
            set(property:"multiple", value: boolean): void;
            get(property:"multiple"): boolean;
            watch(property:"multiple", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A callback to do with an onFetch - but before any items are actually
             * iterated over (i.e. to filter even further what you want to add)
             * 
             */
            "onFetch": Function;
            set(property:"onFetch", value: Function): void;
            get(property:"onFetch"): Function;
            watch(property:"onFetch", callback:{(property?:string, oldValue?:Function, newValue?: Function):void}) :{unwatch():void}
            /**
             * This is the dojo.Deferred returned by setStore().
             * Calling onLoadDeferred.then() registers your
             * callback to be called only once, when the prior setStore completes.
             * 
             */
            "onLoadDeferred": Object;
            set(property:"onLoadDeferred", value: Object): void;
            get(property:"onLoadDeferred"): Object;
            watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The set of options for our select item.  Roughly corresponds to
             * the html <option> tag.
             * 
             */
            "options": Object;
            set(property:"options", value: Object): void;
            get(property:"options"): Object;
            watch(property:"options", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * A query to use when fetching items from our store
             * 
             */
            "query": Object;
            set(property:"query", value: Object): void;
            get(property:"query"): Object;
            watch(property:"query", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Query options to use when fetching from the store
             * 
             */
            "queryOptions": Object;
            set(property:"queryOptions", value: Object): void;
            get(property:"queryOptions"): Object;
            watch(property:"queryOptions", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Can be true or false, default is false.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Flag to sort the options returned from a store by the label of
             * the store.
             * 
             */
            "sortByLabel": boolean;
            set(property:"sortByLabel", value: boolean): void;
            get(property:"sortByLabel"): boolean;
            watch(property:"sortByLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * "Incomplete" if this select is required but unset (i.e. blank value), "" otherwise
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A store to use for getting our list of options - rather than reading them
             * from the <option> html tags.   Should support getIdentity().
             * For back-compat store can also be a dojo/data/api/Identity.
             * 
             */
            "store": Object;
            set(property:"store", value: Object): void;
            get(property:"store"): Object;
            watch(property:"store", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Adds an option or options to the end of the select.  If value
             * of the option is empty or missing, a separator is created instead.
             * Passing in an array of options will yield slightly better performance
             * since the children are only loaded once.
             * 
             * @param option             
             */
            addOption(option: dijit.form._FormSelectWidget.__SelectOption): void;
            /**
             * Adds an option or options to the end of the select.  If value
             * of the option is empty or missing, a separator is created instead.
             * Passing in an array of options will yield slightly better performance
             * since the children are only loaded once.
             * 
             * @param option             
             */
            addOption(option: dijit.form._FormSelectWidget.__SelectOption[]): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * 
             * @param node             
             */
            childSelector(node: HTMLElement): any;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus: boolean): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             * @param preserveDom             
             */
            destroy(preserveDom?: any): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * 
             */
            focus(): void;
            /**
             * Sets the value to the given option, used during search by letter.
             * 
             * @param widget Reference to option's widget             
             */
            focusChild(widget: dijit._WidgetBase): void;
            /**
             * Focus the first focusable child in the container.
             * 
             */
            focusFirstChild(): void;
            /**
             * Focus the last focusable child in the container.
             * 
             */
            focusLastChild(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns a given option (or options).
             * 
             * @param valueOrIdx If passed in as a string, that string is used to look up the optionin the array of options - based on the value property.(See dijit/form/_FormSelectWidget.__SelectOption).If passed in a number, then the option with the given index (0-based)within this select will be returned.If passed in a dijit/form/_FormSelectWidget.__SelectOption, the same option will bereturned if and only if it exists within this select.If passed an array, then an array will be returned with each elementin the array being looked up.If not passed a value, then all options will be returned             
             */
            getOptions(valueOrIdx: any): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            isLoaded(): any;
            /**
             * Whether or not this is a valid value.  The only way a Select
             * can be invalid is when it's required but nothing is selected.
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): boolean};
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * populates the menu
             * 
             * @param loadCallback             
             */
            loadDropDown(loadCallback: Function): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Opens the dropdown for this widget.   To be called only when this.dropDown
             * has been created and is ready to display (ie, it's data is loaded).
             * 
             */
            openDropDown(): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * stop mousemove from selecting text on IE to be consistent with other browsers
             * 
             */
            postCreate(): void;
            /**
             * set the missing message
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the given option or options.  You can remove by string
             * (in which case the value is removed), number (in which case the
             * index in the options array is removed), or select option (in
             * which case, the select option with a matching value is removed).
             * You can also pass in an array of those values for a slightly
             * better performance since the children are only loaded once.
             * For numeric option values, specify {value: number} as the argument.
             * 
             * @param valueOrIdx             
             */
            removeOption(valueOrIdx: String): void;
            /**
             * Removes the given option or options.  You can remove by string
             * (in which case the value is removed), number (in which case the
             * index in the options array is removed), or select option (in
             * which case, the select option with a matching value is removed).
             * You can also pass in an array of those values for a slightly
             * better performance since the children are only loaded once.
             * For numeric option values, specify {value: number} as the argument.
             * 
             * @param valueOrIdx             
             */
            removeOption(valueOrIdx: dijit.form._FormSelectWidget.__SelectOption): void;
            /**
             * Removes the given option or options.  You can remove by string
             * (in which case the value is removed), number (in which case the
             * index in the options array is removed), or select option (in
             * which case, the select option with a matching value is removed).
             * You can also pass in an array of those values for a slightly
             * better performance since the children are only loaded once.
             * For numeric option values, specify {value: number} as the argument.
             * 
             * @param valueOrIdx             
             */
            removeOption(valueOrIdx: number): void;
            /**
             * Removes the given option or options.  You can remove by string
             * (in which case the value is removed), number (in which case the
             * index in the options array is removed), or select option (in
             * which case, the select option with a matching value is removed).
             * You can also pass in an array of those values for a slightly
             * better performance since the children are only loaded once.
             * For numeric option values, specify {value: number} as the argument.
             * 
             * @param valueOrIdx             
             */
            removeOption(valueOrIdx: any[]): void;
            /**
             * Overridden so that the state will be cleared.
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Sets the store you would like to use with this select widget.
             * The selected value is the value of the new store to set.  This
             * function returns the original store, in case you want to reuse
             * it or something.
             * 
             * @param store The dojo.store you would like to use - it MUST implement getIdentity()and MAY implement observe().For backwards-compatibility this can also be a data.data store, in which caseit MUST implement dojo/data/api/Identity,and MAY implement dojo/data/api/Notification.             
             * @param selectedValue               OptionalThe value that this widget should set itself to after the storehas been loaded             
             * @param fetchArgs               OptionalHash of parameters to set filter on store, etc.query: new value for Select.query,queryOptions: new value for Select.queryOptions,onFetch: callback function for each item in data (Deprecated)             
             */
            setStore(store: dojo.store.api.Store, selectedValue: any, fetchArgs: Object): any;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Updates the values of the given option.  The option to update
             * is matched based on the value of the entered option.  Passing
             * in an array of new options will yield better performance since
             * the children will only be loaded once.
             * 
             * @param newOption             
             */
            updateOption(newOption: dijit.form._FormSelectWidget.__SelectOption): void;
            /**
             * Updates the values of the given option.  The option to update
             * is matched based on the value of the entered option.  Passing
             * in an array of new options will yield better performance since
             * the children will only be loaded once.
             * 
             * @param newOption             
             */
            updateOption(newOption: dijit.form._FormSelectWidget.__SelectOption[]): void;
            /**
             * Called by oninit, onblur, and onkeypress, and whenever required/disabled state changes
             * Show missing or invalid messages if appropriate, and highlight textbox field.
             * Used when a select is initially set to no value and the user is required to
             * set the value.
             * 
             * @param isFocused             
             */
            validate(isFocused: boolean): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * When a key is pressed that matches a child item,
             * this method is called so that a widget can take appropriate action is necessary.
             * 
             * @param item             
             * @param evt             
             * @param searchString             
             * @param numMatches             
             */
            onKeyboardSearch(item: dijit._WidgetBase, evt: Event, searchString: String, numMatches: number): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * a function that can be connected to in order to receive a
             * notification that the store has finished loading and all options
             * from that store are available
             * 
             */
            onSetStore(): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module Select {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/Select._Menu.html
             *
             * An internally-used menu for dropdown that allows us a vertical scrollbar
             * 
             * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
             * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
             */
            class _Menu extends dijit.DropDownMenu {
                constructor(params?: Object, srcNodeRef?: HTMLElement);
                /**
                 * This Menu has been clicked (mouse or via space/arrow key) or opened as a submenu,
                 * so mere mouseover will open submenus.  Focusing a menu via TAB does NOT automatically make it active
                 * since TAB is a navigation operation and not a selection one.
                 * For Windows apps, pressing the ALT key focuses the menubar menus (similar to TAB navigation) but the
                 * menu is not active (ie no dropdown) until an item is clicked.
                 * 
                 */
                "activated": boolean;
                set(property:"activated", value: boolean): void;
                get(property:"activated"): boolean;
                watch(property:"activated", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * True if mouse was pressed while over this widget, and hasn't been released yet
                 * 
                 */
                "active": boolean;
                set(property:"active", value: boolean): void;
                get(property:"active"): boolean;
                watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Object to which attach points and events will be scoped.  Defaults
                 * to 'this'.
                 * 
                 */
                "attachScope": Object;
                set(property:"attachScope", value: Object): void;
                get(property:"attachScope"): Object;
                watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                 * for each XXX attribute to be mapped to the DOM.
                 * 
                 * attributeMap sets up a "binding" between attributes (aka properties)
                 * of the widget and the widget's DOM.
                 * Changes to widget attributes listed in attributeMap will be
                 * reflected into the DOM.
                 * 
                 * For example, calling set('title', 'hello')
                 * on a TitlePane will automatically cause the TitlePane's DOM to update
                 * with the new title.
                 * 
                 * attributeMap is a hash where the key is an attribute of the widget,
                 * and the value reflects a binding to a:
                 * 
                 * DOM node attribute
                 *   focus: {node: "focusNode", type: "attribute"}
                 * Maps this.focus to this.focusNode.focus
                 * 
                 * DOM node innerHTML
                 *   title: { node: "titleNode", type: "innerHTML" }
                 * Maps this.title to this.titleNode.innerHTML
                 * 
                 * DOM node innerText
                 *   title: { node: "titleNode", type: "innerText" }
                 * Maps this.title to this.titleNode.innerText
                 * 
                 * DOM node CSS class
                 *   myClass: { node: "domNode", type: "class" }
                 * Maps this.myClass to this.domNode.className
                 * 
                 * If the value is an array, then each element in the array matches one of the
                 * formats of the above list.
                 * 
                 * There are also some shorthands for backwards compatibility:
                 * 
                 * string --> { node: string, type: "attribute" }, for example:
                 * "focusNode" ---> { node: "focusNode", type: "attribute" }
                 * "" --> { node: "domNode", type: "attribute" }
                 * 
                 */
                "attributeMap": Object;
                set(property:"attributeMap", value: Object): void;
                get(property:"attributeMap"): Object;
                watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * 
                 */
                "autoFocus": boolean;
                set(property:"autoFocus", value: boolean): void;
                get(property:"autoFocus"): boolean;
                watch(property:"autoFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * 
                 */
                "baseClass": string;
                set(property:"baseClass", value: string): void;
                get(property:"baseClass"): string;
                watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "class": string;
                set(property:"class", value: string): void;
                get(property:"class"): string;
                watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Designates where children of the source DOM node will be placed.
                 * "Children" in this case refers to both DOM nodes and widgets.
                 * For example, for myWidget:
                 * 
                 * <div data-dojo-type=myWidget>
                 *     <b> here's a plain DOM node
                 *     <span data-dojo-type=subWidget>and a widget</span>
                 *     <i> and another plain DOM node </i>
                 * </div>
                 * containerNode would point to:
                 * 
                 * <b> here's a plain DOM node
                 * <span data-dojo-type=subWidget>and a widget</span>
                 * <i> and another plain DOM node </i>
                 * In templated widgets, "containerNode" is set via a
                 * data-dojo-attach-point assignment.
                 * 
                 * containerNode must be defined for any widget that accepts innerHTML
                 * (like ContentPane or BorderContainer or even Button), and conversely
                 * is null for widgets that don't, like TextBox.
                 * 
                 */
                "containerNode": HTMLElement;
                set(property:"containerNode", value: HTMLElement): void;
                get(property:"containerNode"): HTMLElement;
                watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
                 * need CSS classes applied on mouse hover/press and focus.
                 * 
                 * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
                 * (like "dijitUpArrowButton"). Example:
                 * 
                 * {
                 *     "upArrowButton": "dijitUpArrowButton",
                 *     "downArrowButton": "dijitDownArrowButton"
                 * }
                 * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
                 * 
                 * is hovered, etc.
                 * 
                 */
                "cssStateNodes": Object;
                set(property:"cssStateNodes", value: Object): void;
                get(property:"cssStateNodes"): Object;
                watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Bi-directional support, as defined by the HTML DIR
                 * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                 * default direction.
                 * 
                 */
                "dir": string;
                set(property:"dir", value: string): void;
                get(property:"dir"): string;
                watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This is our visible representation of the widget! Other DOM
                 * Nodes may by assigned to other properties, usually through the
                 * template system's data-dojo-attach-point syntax, but the domNode
                 * property is the canonical "top level" node in widget UI.
                 * 
                 */
                "domNode": HTMLElement;
                set(property:"domNode", value: HTMLElement): void;
                get(property:"domNode"): HTMLElement;
                watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * This widget or a widget it contains has focus, or is "active" because
                 * it was recently clicked.
                 * 
                 */
                "focused": boolean;
                set(property:"focused", value: boolean): void;
                get(property:"focused"): boolean;
                watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * The currently focused child widget, or null if there isn't one
                 * 
                 */
                "focusedChild": Object;
                set(property:"focusedChild", value: Object): void;
                get(property:"focusedChild"): Object;
                watch(property:"focusedChild", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * True if cursor is over this widget
                 * 
                 */
                "hovering": boolean;
                set(property:"hovering", value: boolean): void;
                get(property:"hovering"): boolean;
                watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * A unique, opaque ID string that can be assigned by users or by the
                 * system. If the developer passes an ID which is known not to be
                 * unique, the specified ID is ignored and the system-generated ID is
                 * used instead.
                 * 
                 */
                "id": string;
                set(property:"id", value: string): void;
                get(property:"id"): string;
                watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Rarely used.  Overrides the default Dojo locale used to render this widget,
                 * as defined by the HTML LANG attribute.
                 * Value must be among the list of locales specified during by the Dojo bootstrap,
                 * formatted according to RFC 3066 (like en-us).
                 * 
                 */
                "lang": string;
                set(property:"lang", value: string): void;
                get(property:"lang"): string;
                watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * If multiple characters are typed where each keystroke happens within
                 * multiCharSearchDuration of the previous keystroke,
                 * search for nodes matching all the keystrokes.
                 * 
                 * For example, typing "ab" will search for entries starting with
                 * "ab" unless the delay between "a" and "b" is greater than multiCharSearchDuration.
                 * 
                 */
                "multiCharSearchDuration": number;
                set(property:"multiCharSearchDuration", value: number): void;
                get(property:"multiCharSearchDuration"): number;
                watch(property:"multiCharSearchDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                /**
                 * The document this widget belongs to.  If not specified to constructor, will default to
                 * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                 * 
                 */
                "ownerDocument": Object;
                set(property:"ownerDocument", value: Object): void;
                get(property:"ownerDocument"): Object;
                watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * pointer to menu that displayed me
                 * 
                 */
                "parentMenu": Object;
                set(property:"parentMenu", value: Object): void;
                get(property:"parentMenu"): Object;
                watch(property:"parentMenu", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * For a passive (unclicked) Menu, number of milliseconds before hovering (without clicking) will cause
                 * the popup to open.  Default is Infinity, meaning you need to click the menu to open it.
                 * 
                 */
                "passivePopupDelay": number;
                set(property:"passivePopupDelay", value: number): void;
                get(property:"passivePopupDelay"): number;
                watch(property:"passivePopupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                /**
                 * After a menu has been activated (by clicking on it etc.), number of milliseconds before hovering
                 * (without clicking) another MenuItem causes that MenuItem's popup to automatically open.
                 * 
                 */
                "popupDelay": number;
                set(property:"popupDelay", value: number): void;
                get(property:"popupDelay"): number;
                watch(property:"popupDelay", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                /**
                 * 
                 */
                "searchContainerNode": boolean;
                set(property:"searchContainerNode", value: boolean): void;
                get(property:"searchContainerNode"): boolean;
                watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Currently selected (a.k.a. highlighted) MenuItem, or null if no MenuItem is selected.
                 * If a submenu is open, will be set to MenuItem that displayed the submenu.   OTOH, if
                 * this Menu is in passive mode (i.e. hasn't been clicked yet), will be null, because
                 * "selected" is not merely "hovered".
                 * 
                 */
                "selected": Object;
                set(property:"selected", value: Object): void;
                get(property:"selected"): Object;
                watch(property:"selected", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * pointer to original DOM node
                 * 
                 */
                "srcNodeRef": HTMLElement;
                set(property:"srcNodeRef", value: HTMLElement): void;
                get(property:"srcNodeRef"): HTMLElement;
                watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * HTML style attributes as cssText string or name/value hash
                 * 
                 */
                "style": string;
                set(property:"style", value: string): void;
                get(property:"style"): string;
                watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Tab index of the container; same as HTML tabIndex attribute.
                 * Note then when user tabs into the container, focus is immediately
                 * moved to the first item in the container.
                 * 
                 */
                "tabIndex": string;
                set(property:"tabIndex", value: string): void;
                get(property:"tabIndex"): string;
                watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                 * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                 * 
                 */
                "templatePath": string;
                set(property:"templatePath", value: string): void;
                get(property:"templatePath"): string;
                watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "templateString": string;
                set(property:"templateString", value: string): void;
                get(property:"templateString"): string;
                watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * HTML title attribute.
                 * 
                 * For form widgets this specifies a tooltip to display when hovering over
                 * the widget (just like the native HTML title attribute).
                 * 
                 * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                 * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                 * interpreted as HTML.
                 * 
                 */
                "title": string;
                set(property:"title", value: string): void;
                get(property:"title"): string;
                watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                 * this specifies the tooltip to appear when the mouse is hovered over that text.
                 * 
                 */
                "tooltip": string;
                set(property:"tooltip", value: string): void;
                get(property:"tooltip"): string;
                watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 * @param widget             
                 * @param insertIndex               Optional            
                 */
                addChild(widget: dijit._WidgetBase, insertIndex: number): void;
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: String, value: Object): any;
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: Object, value: Object): any;
                /**
                 * 
                 */
                buildRendering(): void;
                /**
                 * Selector (passed to on.selector()) used to identify MenuItem child widgets, but exclude inert children
                 * like MenuSeparator.  If subclass overrides to a string (ex: "> *"), the subclass must require dojo/query.
                 * 
                 * @param node             
                 */
                childSelector(node: HTMLElement): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: Function): any;
                /**
                 * Deprecated.  You can call this in postCreate() to attach the keyboard handlers to the container,
                 * but the preferred method is to override _onLeftArrow() and _onRightArrow(), or
                 * _onUpArrow() and _onDownArrow(), to call focusPrev() and focusNext().
                 * 
                 * @param prevKeyCodes Key codes for navigating to the previous child.             
                 * @param nextKeyCodes Key codes for navigating to the next child.             
                 */
                connectKeyNavHandlers(prevKeyCodes: dojo.keys, nextKeyCodes: dojo.keys): void;
                /**
                 * Wrapper to setTimeout to avoid deferred functions executing
                 * after the originating widget has been destroyed.
                 * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                 * 
                 * @param fcn Function reference.             
                 * @param delay               OptionalDelay, defaults to 0.             
                 */
                defer(fcn: Function, delay: number): Object;
                /**
                 * Destroy this widget, but not its descendants.  Descendants means widgets inside of
                 * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
                 * 
                 * This method will also destroy internal widgets such as those created from a template,
                 * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
                 * 
                 * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
                 * depend on the current ability to destroy a widget without destroying its descendants.   Generally
                 * they should use destroyRecursive() for widgets with children.
                 * 
                 * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
                 */
                destroy(preserveDom?: boolean): void;
                /**
                 * Recursively destroy the children of this widget and their
                 * descendants.
                 * 
                 * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                 */
                destroyDescendants(preserveDom?: boolean): void;
                /**
                 * Destroy this widget and its descendants
                 * This is the generic "destructor" function that all widget users
                 * should call to cleanly discard with a widget. Once a widget is
                 * destroyed, it is removed from the manager object.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                 */
                destroyRecursive(preserveDom?: boolean): void;
                /**
                 * Destroys the DOM nodes associated with this widget.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                 */
                destroyRendering(preserveDom?: boolean): void;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Disconnects handle created by connect.
                 * 
                 * @param handle             
                 */
                disconnect(handle: any): void;
                /**
                 * Used by widgets to signal that a synthetic event occurred, ex:
                 * 
                 * myWidget.emit("attrmodified-selectedChildWidget", {}).
                 * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                 * Also calls onType() method, if present, and returns value from that method.
                 * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                 * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                 * 
                 * @param type             
                 * @param eventObj               Optional            
                 * @param callbackArgs               Optional            
                 */
                emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                /**
                 * Overridden so that the previously selected value will be focused instead of only the first item
                 * 
                 */
                focus(): void;
                /**
                 * Focus specified child widget.
                 * 
                 * @param widget Reference to container's child widget             
                 * @param last If true and if widget has multiple focusable nodes, focus thelast one instead of the first one             
                 */
                focusChild(widget: dijit._WidgetBase, last: boolean): void;
                /**
                 * Focus the first focusable child in the container.
                 * 
                 */
                focusFirstChild(): void;
                /**
                 * Focus the last focusable child in the container.
                 * 
                 */
                focusLastChild(): void;
                /**
                 * Focus the next widget
                 * 
                 */
                focusNext(): void;
                /**
                 * Focus the last focusable node in the previous widget
                 * (ex: go to the ComboButton icon section rather than button section)
                 * 
                 */
                focusPrev(): void;
                /**
                 * Get a property from a widget.
                 * Get a named property from a widget. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _getFooAttr(), calling:
                 * myWidget.get("foo") would be equivalent to calling
                 * widget._getFooAttr() and myWidget.get("bar")
                 * would be equivalent to the expression
                 * widget.bar2
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                 * is this widget.   Note that it does not return all descendants, but rather just direct children.
                 * Analogous to Node.childNodes,
                 * except containing widgets rather than DOMNodes.
                 * 
                 * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                 * outside of this.containerNode.
                 * 
                 * Note that the array returned is a simple array.  Application code should not assume
                 * existence of methods like forEach().
                 * 
                 */
                getChildren(): any[];
                /**
                 * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                 * This method should generally be avoided as it returns widgets declared in templates, which are
                 * supposed to be internal/hidden, but it's left here for back-compat reasons.
                 * 
                 */
                getDescendants(): any[];
                /**
                 * Gets the index of the child in this container or -1 if not found
                 * 
                 * @param child             
                 */
                getIndexOfChild(child: dijit._WidgetBase): any;
                /**
                 * Returns the parent widget of this widget.
                 * 
                 */
                getParent(): any;
                /**
                 * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
                 * 
                 */
                hasChildren(): boolean;
                /**
                 * Return true if this widget can currently be focused
                 * and false if not
                 * 
                 */
                isFocusable(): any;
                /**
                 * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                 * 
                 */
                isLeftToRight(): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: String, func: Function): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: Function, func: Function): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: number): any;
                /**
                 * stop mousemove from selecting text on IE to be consistent with other browsers
                 * 
                 */
                postCreate(): void;
                /**
                 * Called after the parameters to the widget have been read-in,
                 * but before the widget template is instantiated. Especially
                 * useful to set properties that are referenced in the widget
                 * template.
                 * 
                 */
                postMixInProperties(): void;
                /**
                 * Removes the passed widget instance from this widget but does
                 * not destroy it.  You can also pass in an integer indicating
                 * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
                 * 
                 * @param widget             
                 */
                removeChild(widget: dijit._WidgetBase): void;
                /**
                 * Removes the passed widget instance from this widget but does
                 * not destroy it.  You can also pass in an integer indicating
                 * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
                 * 
                 * @param widget             
                 */
                removeChild(widget: number): void;
                /**
                 * Set a property on a widget
                 * Sets named properties on a widget which may potentially be handled by a
                 * setter in the widget.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _setFooAttr(), calling
                 * myWidget.set("foo", "Howdy!") would be equivalent to calling
                 * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                 * would be equivalent to the statement widget.bar = 3;
                 * 
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * myWidget.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * });
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: any, value: any): any;
                /**
                 * Deprecated.  Use set() instead.
                 * 
                 * @param attr             
                 * @param value             
                 */
                setAttribute(attr: String, value: any): void;
                /**
                 * Processing after the DOM fragment is added to the document
                 * Called after a widget and its children have been created and added to the page,
                 * and all related widgets have finished their create() cycle, up through postCreate().
                 * 
                 * Note that startup() may be called while the widget is still hidden, for example if the widget is
                 * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
                 * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
                 * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
                 * 
                 */
                startup(): void;
                /**
                 * 
                 */
                startupKeyNavChildren(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                 * 
                 * Subscribes to the specified topic and calls the specified method
                 * of this object and registers for unsubscribe() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.subscribe, except with the
                 * implicit use of this widget as the target object.
                 * 
                 * @param t The topic             
                 * @param method The callback             
                 */
                subscribe(t: String, method: Function): any;
                /**
                 * Returns a string that represents the widget.
                 * When a widget is cast to a string, this method will be used to generate the
                 * output. Currently, it does not implement any sort of reversible
                 * serialization.
                 * 
                 */
                toString(): string;
                /**
                 * Deprecated. Override destroy() instead to implement custom widget tear-down
                 * behavior.
                 * 
                 */
                uninitialize(): boolean;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Unsubscribes handle created by this.subscribe.
                 * Also removes handle from this widget's list of subscriptions
                 * 
                 * @param handle             
                 */
                unsubscribe(handle: Object): void;
                /**
                 * Watches a property for changes
                 * 
                 * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                 * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                 */
                watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                /**
                 * Static method to get a template based on the templatePath or
                 * templateString key
                 */
                getCachedTemplate(): any;
                /**
                 * Called when the widget stops being "active" because
                 * focus moved to something outside of it, or the user
                 * clicked somewhere outside of it, or the widget was
                 * hidden.
                 * 
                 */
                onBlur(): void;
                /**
                 * Attach point for notification about when the user cancels the current menu
                 * This is an internal mechanism used for Menus to signal to their parent to
                 * close them.  In general developers should not attach to or override this method.
                 * 
                 * @param closeAll             
                 */
                onCancel(closeAll: boolean): void;
                /**
                 * Connect to this function to receive notifications of mouse click events.
                 * 
                 * @param event mouse Event             
                 */
                onClick(event: any): void;
                /**
                 * Connect to this function to receive notifications of mouse double click events.
                 * 
                 * @param event mouse Event             
                 */
                onDblClick(event: any): void;
                /**
                 * Attach point for notification about when a menu item has been executed.
                 * This is an internal mechanism used for Menus to signal to their parent to
                 * close them, because they are about to execute the onClick handler.  In
                 * general developers should not attach to or override this method.
                 * 
                 */
                onExecute(): void;
                /**
                 * Called when the widget becomes "active" because
                 * it or a widget inside of it either has focus, or has recently
                 * been clicked.
                 * 
                 */
                onFocus(): void;
                /**
                 * Called when another widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onHide(): void;
                /**
                 * Called when cursor is over a MenuItem.
                 * 
                 * @param item             
                 */
                onItemHover(item: dijit.MenuItem): void;
                /**
                 * Callback fires when mouse exits a MenuItem
                 * 
                 * @param item             
                 */
                onItemUnhover(item: dijit.MenuItem): void;
                /**
                 * Attach point for notification about when a menu item has been searched for
                 * via the keyboard search mechanism.
                 * 
                 * @param item             
                 * @param evt             
                 * @param searchString             
                 * @param numMatches             
                 */
                onKeyboardSearch(item: dijit.MenuItem, evt: Event, searchString: String, numMatches: number): void;
                /**
                 * Connect to this function to receive notifications of keys being pressed down.
                 * 
                 * @param event key Event             
                 */
                onKeyDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of printable keys being typed.
                 * 
                 * @param event key Event             
                 */
                onKeyPress(event: any): void;
                /**
                 * Connect to this function to receive notifications of keys being released.
                 * 
                 * @param event key Event             
                 */
                onKeyUp(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is pressed down.
                 * 
                 * @param event mouse Event             
                 */
                onMouseDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseEnter(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseLeave(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseMove(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOut(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOver(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is released.
                 * 
                 * @param event mouse Event             
                 */
                onMouseUp(event: any): void;
                /**
                 * Called when this widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onShow(): void;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/TextBox.html
         *
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class TextBox extends dijit.form._FormValueWidget implements dijit.form._TextBoxMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": Object;
            set(property:"value", value: Object): void;
            get(property:"value"): Object;
            watch(property:"value", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Select text in the input element argument, from start (default 0), to stop (default end).
             * 
             * @param element             
             * @param start               Optional            
             * @param stop               Optional            
             */
            selectInputText(element: HTMLElement, start: number, stop: number): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/TimeTextBox.html
         *
         * A validating, serializable, range-bound time text box with a drop down time picker
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree     
         */
        class TimeTextBox extends dijit.form._DateTimeTextBox {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "autoWidth": boolean;
            set(property:"autoWidth", value: boolean): void;
            get(property:"autoWidth"): boolean;
            watch(property:"autoWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * JavaScript namespace to find calendar routines.  If unspecified, uses Gregorian calendar routines
             * at dojo/date and dojo/date/locale.
             * 
             */
            "datePackage": string;
            set(property:"datePackage", value: string): void;
            get(property:"datePackage"): string;
            watch(property:"datePackage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The widget to display as a popup.  This widget must be
             * defined before the startup function is called.
             * 
             */
            "dropDown": Object;
            set(property:"dropDown", value: Object): void;
            get(property:"dropDown"): Object;
            watch(property:"dropDown", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The default value to focus in the popupClass widget when the textbox value is empty.
             * 
             */
            "dropDownDefaultValue": Date;
            set(property:"dropDownDefaultValue", value: Date): void;
            get(property:"dropDownDefaultValue"): Date;
            watch(property:"dropDownDefaultValue", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
            /**
             * This variable controls the position of the drop down.
             * It's an array of strings with the following values:
             * 
             * before: places drop down to the left of the target node/widget, or to the right in
             * the case of RTL scripts like Hebrew and Arabic
             * after: places drop down to the right of the target node/widget, or to the left in
             * the case of RTL scripts like Hebrew and Arabic
             * above: drop down goes above target node
             * below: drop down goes below target node
             * The list is positions is tried, in order, until a position is found where the drop down fits
             * within the viewport.
             * 
             */
            "dropDownPosition": Object;
            set(property:"dropDownPosition", value: Object): void;
            get(property:"dropDownPosition"): Object;
            watch(property:"dropDownPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set to true to make the drop down exactly as wide as this
             * widget.  Overrides autoWidth.
             * 
             */
            "forceWidth": boolean;
            set(property:"forceWidth", value: boolean): void;
            get(property:"forceWidth"): boolean;
            watch(property:"forceWidth", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this textbox to display a down arrow button, to open the drop down list.
             * 
             */
            "hasDownArrow": boolean;
            set(property:"hasDownArrow", value: boolean): void;
            get(property:"hasDownArrow"): boolean;
            watch(property:"hasDownArrow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "maxHeight": number;
            set(property:"maxHeight", value: number): void;
            get(property:"maxHeight"): number;
            watch(property:"maxHeight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is out-of-range
             * 
             */
            "rangeMessage": string;
            set(property:"rangeMessage", value: string): void;
            get(property:"rangeMessage"): string;
            watch(property:"rangeMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The value of this widget as a JavaScript Date object.  Note that the date portion implies time zone and daylight savings rules.
             * 
             * Example:
             * 
             * new dijit/form/TimeTextBox({value: stamp.fromISOString("T12:59:59", new Date())})
             * When passed to the parser in markup, must be specified according to locale-independent
             * stamp.fromISOString format.
             * 
             * Example:
             * 
             * <input data-dojo-type='dijit/form/TimeTextBox' value='T12:34:00'>
             * 
             */
            "value": Date;
            set(property:"value", value: Date): void;
            get(property:"value"): Date;
            watch(property:"value", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Closes the drop down on this widget
             * 
             * @param focus If true, refocuses the button widget             
             */
            closeDropDown(focus: boolean): void;
            /**
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: Date, val2: Date): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Formats the value as a Date, according to specified locale (second argument)
             * 
             * @param value             
             * @param constraints An object with the following properties:selector (String): choice of 'time','date' (default: date and time)formatLength (String): choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'datePattern (String): override pattern with this stringtimePattern (String): override pattern with this stringam (String): override strings for am in timespm (String): override strings for pm in timeslocale (String): override the locale used to determine formatting rulesfullYear (Boolean): (format only) use 4 digit years whenever 2 digit years are called forstrict (Boolean): (parse only) strict parsing, off by default            
             */
            format(value: Date, constraints: Object): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Tests if the value is in the min/max range specified in constraints
             * 
             * @param isFocused             
             */
            isInRange(isFocused: boolean): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Returns true if the dropdown exists and it's data is loaded.  This can
             * be overridden in order to force a call to loadDropDown().
             * 
             */
            isLoaded(): boolean;
            /**
             * 
             * @param isFocused             
             */
            isValid: {(isFocused: boolean): any};
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and
             * then opens the drop down.  This is basically a callback when the
             * user presses the down arrow button to open the drop down.
             * 
             */
            loadAndOpenDropDown(): any;
            /**
             * Creates the drop down if it doesn't exist, loads the data
             * if there's an href and it hasn't been loaded yet, and then calls
             * the given callback.
             * 
             * @param loadCallback             
             */
            loadDropDown(loadCallback: Function): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * 
             * @param callback             
             */
            openDropDown(callback: Function): void;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Parses as string as a Date, according to constraints
             * 
             * @param value             
             * @param constraints An object with the following properties:selector (String): choice of 'time','date' (default: date and time)formatLength (String): choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'datePattern (String): override pattern with this stringtimePattern (String): override pattern with this stringam (String): override strings for am in timespm (String): override strings for pm in timeslocale (String): override the locale used to determine formatting rulesfullYear (Boolean): (format only) use 4 digit years whenever 2 digit years are called forstrict (Boolean): (parse only) strict parsing, off by default            
             */
            parse(value: String, constraints: Object): any;
            /**
             * Builds the regular needed to parse a localized date
             * 
             * @param options               OptionalAn object with the following properties:selector (String): choice of 'time','date' (default: date and time)formatLength (String): choice of long, short, medium or full (plus any custom additions).  Defaults to 'short'datePattern (String): override pattern with this stringtimePattern (String): override pattern with this stringam (String): override strings for am in timespm (String): override strings for pm in timeslocale (String): override the locale used to determine formatting rulesfullYear (Boolean): (format only) use 4 digit years whenever 2 digit years are called forstrict (Boolean): (parse only) strict parsing, off by default            
             */
            pattern: {(options: Object): any};
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            popupClass: {(): void};
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Overridable function used to validate the range of the numeric input value.
             * 
             * @param primitive             
             * @param constraints             
             */
            rangeCheck(primitive: number, constraints: dijit.form.RangeBoundTextBox.__Constraints): boolean;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * 
             * @param val             
             * @param options               Optional            
             */
            serialize(val: any, options: Object): any;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Callback when the user presses the down arrow button or presses
             * the down arrow key to open/close the drop down.
             * Toggle the drop-down widget; if it is up, close it, if not, open it
             * 
             */
            toggleDropDown(): void;
            /**
             * Returns widget as a printable string using the widget's value
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * 
             */
            validate(): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/ToggleButton.html
         *
         * A templated button widget that can be in two states (checked or not).
         * Can be base class for things like tabs or checkbox or radio buttons.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class ToggleButton extends dijit.form.Button implements dijit.form._ToggleButtonMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * In markup, specified as "checked='checked'" or just "checked".
             * True if the button is depressed, or the checkbox is checked,
             * or the radio button is selected, etc.
             * 
             */
            "checked": boolean;
            set(property:"checked", value: boolean): void;
            get(property:"checked"): boolean;
            watch(property:"checked", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Class to apply to DOMNode in button to make it display an icon
             * 
             */
            "iconClass": string;
            set(property:"iconClass", value: string): void;
            get(property:"iconClass"): string;
            watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Content to display in button.
             * 
             */
            "label": string;
            set(property:"label", value: string): void;
            get(property:"label"): string;
            watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Set this to true to hide the label text and display only the icon.
             * (If showLabel=false then iconClass must be specified.)
             * Especially useful for toolbars.
             * If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
             * 
             * The exception case is for computers in high-contrast mode, where the label
             * will still be displayed, since the icon doesn't appear.
             * 
             */
            "showLabel": boolean;
            set(property:"showLabel", value: boolean): void;
            get(property:"showLabel"): boolean;
            watch(property:"showLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": string;
            set(property:"value", value: string): void;
            get(property:"value"): string;
            watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('checked', true/false) instead.
             * 
             * @param checked             
             */
            setChecked(checked: boolean): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('label', ...) instead.
             * 
             * @param content             
             */
            setLabel(content: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: Event): boolean;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/VerticalRule.html
         *
         * Hash marks for the dijit/form/VerticalSlider
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class VerticalRule extends dijit.form.HorizontalRule {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is either "leftDecoration" or "rightDecoration",
             * to indicate whether this rule goes to the left or to the right of the slider.
             * Note that on RTL system, "leftDecoration" would actually go to the right, and vice-versa.
             * 
             */
            "container": string;
            set(property:"container", value: string): void;
            get(property:"container"): string;
            watch(property:"container", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Number of hash marks to generate
             * 
             */
            "count": number;
            set(property:"count", value: number): void;
            get(property:"count"): number;
            watch(property:"count", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * CSS style to apply to individual hash marks
             * 
             */
            "ruleStyle": string;
            set(property:"ruleStyle", value: string): void;
            get(property:"ruleStyle"): string;
            watch(property:"ruleStyle", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/VerticalRuleLabels.html
         *
         * Labels for the dijit/form/VerticalSlider
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class VerticalRuleLabels extends dijit.form.HorizontalRuleLabels {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
             * widget state.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * pattern, places, lang, et al (see dojo.number) for generated numeric labels when labels[] are not specified
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * For HorizontalSlider, this is either "topDecoration" or "bottomDecoration",
             * and indicates whether this rule goes above or below the slider.
             * 
             */
            "container": string;
            set(property:"container", value: string): void;
            get(property:"container"): string;
            watch(property:"container", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Number of hash marks to generate
             * 
             */
            "count": number;
            set(property:"count", value: number): void;
            get(property:"count"): number;
            watch(property:"count", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Array of text labels to render - evenly spaced from left-to-right or bottom-to-top.
             * Alternately, minimum and maximum can be specified, to get numeric labels.
             * 
             */
            "labels": Object;
            set(property:"labels", value: Object): void;
            get(property:"labels"): Object;
            watch(property:"labels", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * CSS style to apply to individual text labels
             * 
             */
            "labelStyle": string;
            set(property:"labelStyle", value: string): void;
            get(property:"labelStyle"): string;
            watch(property:"labelStyle", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "maximum": number;
            set(property:"maximum", value: number): void;
            get(property:"maximum"): number;
            watch(property:"maximum", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * 
             */
            "minimum": number;
            set(property:"minimum", value: number): void;
            get(property:"minimum"): number;
            watch(property:"minimum", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Number of generated numeric labels that should be rendered as '' on the ends when labels[] are not specified
             * 
             */
            "numericMargin": number;
            set(property:"numericMargin", value: number): void;
            get(property:"numericMargin"): number;
            watch(property:"numericMargin", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * CSS style to apply to individual hash marks
             * 
             */
            "ruleStyle": string;
            set(property:"ruleStyle", value: string): void;
            get(property:"ruleStyle"): string;
            watch(property:"ruleStyle", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Overridable function to return array of labels to use for this slider.
             * Can specify a getLabels() method instead of a labels[] array, or min/max attributes.
             * 
             */
            getLabels(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/ValidationTextBox.html
         *
         * Base class for textbox widgets with the ability to validate content of various types and provide user feedback.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree.     
         */
        class ValidationTextBox extends dijit.form.TextBox {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * user-defined object needed to pass parameters to the validator functions
             * 
             */
            "constraints": Object;
            set(property:"constraints", value: Object): void;
            get(property:"constraints"): Object;
            watch(property:"constraints", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
             * need CSS classes applied on mouse hover/press and focus.
             * 
             * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
             * (like "dijitUpArrowButton"). Example:
             * 
             * {
             *     "upArrowButton": "dijitUpArrowButton",
             *     "downArrowButton": "dijitDownArrowButton"
             * }
             * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
             * 
             * is hovered, etc.
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * For subclasses like ComboBox where the displayed value
             * (ex: Kentucky) and the serialized value (ex: KY) are different,
             * this represents the displayed value.
             * 
             * Setting 'displayedValue' through set('displayedValue', ...)
             * updates 'value', and vice-versa.  Otherwise 'value' is updated
             * from 'displayedValue' periodically, like onBlur etc.
             * 
             * TODO: move declaration to MappedTextBox?
             * Problem is that ComboBox references displayedValue,
             * for benefit of FilteringSelect.
             * 
             */
            "displayedValue": string;
            set(property:"displayedValue", value: string): void;
            get(property:"displayedValue"): string;
            watch(property:"displayedValue", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The message to display if value is invalid.
             * The translated string value is read from the message file by default.
             * Set to "" to use the promptMessage instead.
             * 
             */
            "invalidMessage": string;
            set(property:"invalidMessage", value: string): void;
            get(property:"invalidMessage"): string;
            watch(property:"invalidMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "isValid": any;
            set(property:"isValid", value: any): void;
            get(property:"isValid"): any;
            watch(property:"isValid", callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to lowercase if true.  Default is false.
             * 
             */
            "lowercase": boolean;
            set(property:"lowercase", value: boolean): void;
            get(property:"lowercase"): boolean;
            watch(property:"lowercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML INPUT tag maxLength declaration.
             * 
             */
            "maxLength": string;
            set(property:"maxLength", value: string): void;
            get(property:"maxLength"): string;
            watch(property:"maxLength", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Currently error/prompt message.
             * When using the default tooltip implementation, this will only be
             * displayed when the field is focused.
             * 
             */
            "message": string;
            set(property:"message", value: string): void;
            get(property:"message"): string;
            watch(property:"message", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The message to display if value is empty and the field is required.
             * The translated string value is read from the message file by default.
             * Set to "" to use the invalidMessage instead.
             * 
             */
            "missingMessage": string;
            set(property:"missingMessage", value: string): void;
            get(property:"missingMessage"): string;
            watch(property:"missingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This defines the regular expression used to validate the input.
             * Do not add leading ^ or $ characters since the widget adds these.
             * A function may be used to generate a valid pattern when dependent on constraints or other runtime factors.
             * set('pattern', String|Function).
             * 
             */
            "pattern": string;
            set(property:"pattern", value: string): void;
            get(property:"pattern"): string;
            watch(property:"pattern", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines a hint to help users fill out the input field (as defined in HTML 5).
             * This should only contain plain text (no html markup).
             * 
             */
            "placeHolder": string;
            set(property:"placeHolder", value: string): void;
            get(property:"placeHolder"): string;
            watch(property:"placeHolder", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If defined, display this hint string immediately on focus to the textbox, if empty.
             * Also displays if the textbox value is Incomplete (not yet valid but will be with additional input).
             * Think of this like a tooltip that tells the user what to do, not an error message
             * that tells the user what they've done wrong.
             * 
             * Message disappears when user starts typing.
             * 
             */
            "promptMessage": string;
            set(property:"promptMessage", value: string): void;
            get(property:"promptMessage"): string;
            watch(property:"promptMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts the first character of each word to uppercase if true.
             * 
             */
            "propercase": boolean;
            set(property:"propercase", value: boolean): void;
            get(property:"propercase"): boolean;
            watch(property:"propercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "regExp": string;
            set(property:"regExp", value: string): void;
            get(property:"regExp"): string;
            watch(property:"regExp", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * User is required to enter data into this field.
             * 
             */
            "required": boolean;
            set(property:"required", value: boolean): void;
            get(property:"required"): boolean;
            watch(property:"required", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If true, all text will be selected when focused with mouse
             * 
             */
            "selectOnClick": boolean;
            set(property:"selectOnClick", value: boolean): void;
            get(property:"selectOnClick"): boolean;
            watch(property:"selectOnClick", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Shows current state (ie, validation result) of input (""=Normal, Incomplete, or Error)
             * 
             */
            "state": string;
            set(property:"state", value: string): void;
            get(property:"state"): string;
            watch(property:"state", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * See description of dijit/Tooltip.defaultPosition for details on this parameter.
             * 
             */
            "tooltipPosition": Object;
            set(property:"tooltipPosition", value: Object): void;
            get(property:"tooltipPosition"): Object;
            watch(property:"tooltipPosition", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Removes leading and trailing whitespace if true.  Default is false.
             * 
             */
            "trim": boolean;
            set(property:"trim", value: boolean): void;
            get(property:"trim"): boolean;
            watch(property:"trim", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Converts all characters to uppercase if true.  Default is false.
             * 
             */
            "uppercase": boolean;
            set(property:"uppercase", value: boolean): void;
            get(property:"uppercase"): boolean;
            watch(property:"uppercase", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "value": Object;
            set(property:"value", value: Object): void;
            get(property:"value"): Object;
            watch(property:"value", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Overridable method to display validation errors/hints.
             * By default uses a tooltip.
             * 
             * @param message             
             */
            displayMessage(message: String): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Auto-corrections (such as trimming) that are applied to textbox
             * value on blur or form submit.
             * For MappedTextBox subclasses, this is called twice
             * 
             * once with the display value
             * once the value as set/returned by set('value', ...)
             * and get('value'), ex: a Number for NumberTextBox.
             * 
             * In the latter case it does corrections like converting null to NaN.  In
             * the former case the NumberTextBox.filter() method calls this.inherited()
             * to execute standard trimming code in TextBox.filter().
             * 
             * TODO: break this into two methods in 2.0
             * 
             * @param val             
             */
            filter(val: any): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Replaceable function to convert a value to a properly formatted string.
             * 
             * @param value             
             * @param constraints             
             */
            format(value: String, constraints: Object): String;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Deprecated.  Use get('displayedValue') instead.
             * 
             */
            getDisplayedValue(): any;
            /**
             * Return an error message to show if appropriate
             * 
             * @param isFocused             
             */
            getErrorMessage(isFocused: boolean): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Return a hint message to show when widget is first focused
             * 
             * @param isFocused             
             */
            getPromptMessage(isFocused: boolean): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Replaceable function to convert a formatted string to a value
             * 
             * @param value             
             * @param constraints             
             */
            parse(value: String, constraints: Object): String;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Deprecated.  Use set('pattern', Function) instead.
             * 
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            regExpGen(constraints: Object): void;
            /**
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('displayedValue', ...) instead.
             * 
             * @param value             
             */
            setDisplayedValue(value: String): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Called by oninit, onblur, and onkeypress.
             * Show missing or invalid messages if appropriate, and highlight textbox field.
             * 
             * @param isFocused             
             */
            validate(isFocused: boolean): any;
            /**
             * Overridable function used to validate the text input against the regular expression.
             * 
             * @param value             
             * @param constraints An object with the following properties:locale (String): locale used for validation, picks up value from this widget's lang attribute_flags_ (anything): various flags passed to pattern function            
             */
            validator(value: any, constraints: Object): any;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of various user data-input events.
             * Return false to cancel the event and prevent it from being processed.
             * 
             * @param event keydown | keypress | cut | paste | input             
             */
            onInput(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/VerticalSlider.html
         *
         * A form widget that allows one to select a value with a vertically draggable handle
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class VerticalSlider extends dijit.form.HorizontalSlider {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "alt": string;
            set(property:"alt", value: string): void;
            get(property:"alt"): string;
            watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "aria-label": string;
            set(property:"aria-label", value: string): void;
            get(property:"aria-label"): string;
            watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If clicking the slider bar changes the value or not
             * 
             */
            "clickSelect": boolean;
            set(property:"clickSelect", value: boolean): void;
            get(property:"clickSelect"): boolean;
            watch(property:"clickSelect", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "disabled='disabled'", or just "disabled".
             * 
             */
            "disabled": boolean;
            set(property:"disabled", value: boolean): void;
            get(property:"disabled"): boolean;
            watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If specified, indicates that the slider handle has only 'discreteValues' possible positions,
             * and that after dragging the handle, it will snap to the nearest possible position.
             * Thus, the slider has only 'discreteValues' possible values.
             * 
             * For example, if minimum=10, maxiumum=30, and discreteValues=3, then the slider handle has
             * three possible positions, representing values 10, 20, or 30.
             * 
             * If discreteValues is not specified or if it's value is higher than the number of pixels
             * in the slider bar, then the slider handle can be moved freely, and the slider's value will be
             * computed/reported based on pixel position (in this case it will likely be fractional,
             * such as 123.456789).
             * 
             */
            "discreteValues": number;
            set(property:"discreteValues", value: number): void;
            get(property:"discreteValues"): number;
            watch(property:"discreteValues", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Fires onChange for each value change or only on demand
             * 
             */
            "intermediateChanges": boolean;
            set(property:"intermediateChanges", value: boolean): void;
            get(property:"intermediateChanges"): boolean;
            watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The maximum value the slider can be set to.
             * 
             */
            "maximum": number;
            set(property:"maximum", value: number): void;
            get(property:"maximum"): number;
            watch(property:"maximum", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The minimum value the slider can be set to.
             * 
             */
            "minimum": number;
            set(property:"minimum", value: number): void;
            get(property:"minimum"): number;
            watch(property:"minimum", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Name used when submitting form; same as "name" attribute or plain HTML elements
             * 
             */
            "name": string;
            set(property:"name", value: string): void;
            get(property:"name"): string;
            watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * If discreteValues is also specified, this indicates the amount of clicks (ie, snap positions)
             * that the slider handle is moved via pageup/pagedown keys.
             * If discreteValues is not specified, it indicates the number of pixels.
             * 
             */
            "pageIncrement": number;
            set(property:"pageIncrement", value: number): void;
            get(property:"pageIncrement"): number;
            watch(property:"pageIncrement", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Should this widget respond to user input?
             * In markup, this is specified as "readOnly".
             * Similar to disabled except readOnly form values are submitted.
             * 
             */
            "readOnly": boolean;
            set(property:"readOnly", value: boolean): void;
            get(property:"readOnly"): boolean;
            watch(property:"readOnly", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * On focus, should this widget scroll into view?
             * 
             */
            "scrollOnFocus": boolean;
            set(property:"scrollOnFocus", value: boolean): void;
            get(property:"scrollOnFocus"): boolean;
            watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Show increment/decrement buttons at the ends of the slider?
             * 
             */
            "showButtons": boolean;
            set(property:"showButtons", value: boolean): void;
            get(property:"showButtons"): boolean;
            watch(property:"showButtons", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The time in ms to take to animate the slider handle from 0% to 100%,
             * when clicking the slider bar to make the handle move.
             * 
             */
            "slideDuration": number;
            set(property:"slideDuration", value: number): void;
            get(property:"slideDuration"): number;
            watch(property:"slideDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Corresponds to the native HTML <input> element's attribute.
             * 
             */
            "type": string;
            set(property:"type", value: string): void;
            get(property:"type"): string;
            watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "value": number;
            set(property:"value", value: number): void;
            get(property:"value"): number;
            watch(property:"value", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Compare 2 values (as returned by get('value') for this widget).
             * 
             * @param val1             
             * @param val2             
             */
            compare(val1: any, val2: any): number;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Put focus on this widget
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Deprecated.  Use get('value') instead.
             * 
             */
            getValue(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * Reset the widget's value to what it was at initialization time
             * 
             */
            reset(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.  Use set('disabled', ...) instead.
             * 
             * @param disabled             
             */
            setDisabled(disabled: boolean): void;
            /**
             * Deprecated.  Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: String): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Restore the value to the last value passed to onChange
             * 
             */
            undo(): void;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Callback when this widget's value is changed.
             * 
             * @param newValue             
             */
            onChange(newValue: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/form/Slider.html
         *
         * Rollup of all the the Slider related widgets
         * For back-compat, remove for 2.0
         * 
         */
        interface Slider {
        }
    }

    module layout {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/_ContentPaneResizeMixin.html
         *
         * Resize() functionality of ContentPane.   If there's a single layout widget
         * child then it will call resize() with the same dimensions as the ContentPane.
         * Otherwise just calls resize on each child.
         * 
         * Also implements basic startup() functionality, where starting the parent
         * will start the children
         * 
         */
        class _ContentPaneResizeMixin {
            constructor();
            /**
             * 
             * 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.resize() for description.
             * Although ContentPane doesn't extend _LayoutWidget, it does implement
             * the same API.
             * 
             * @param changeSize             
             * @param resultSize             
             */
            resize(changeSize: any, resultSize: any): void;
            /**
             * See dijit/layout/_LayoutWidget.startup() for description.
             * Although ContentPane doesn't extend _LayoutWidget, it does implement
             * the same API.
             * 
             */
            startup(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/_LayoutWidget.html
         *
         * 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.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _LayoutWidget extends dijit._Widget implements dijit._Container, dijit._Contained {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * This class name is applied to the widget's domNode
             * and also may be used to generate names for sub nodes,
             * for example dijitTabContainer-content.
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Indicates that this widget is going to call resize() on its
             * children widgets, setting their size, when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * @param child             
             * @param insertIndex               Optional            
             */
            addChild(child: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the index of this widget within its container parent.
             * It returns -1 if the parent does not exist, or if the parent
             * is not a dijit/_Container
             * 
             */
            getIndexInParent(): any;
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns null if this is the last child of the parent,
             * otherwise returns the next element sibling to the "right".
             * 
             */
            getNextSibling(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns null if this is the first child of the parent,
             * otherwise returns the next element sibling to the "left".
             * 
             */
            getPreviousSibling(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 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;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * 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:
             * 
             * Sets this._borderBox and this._contentBox to the new size of
             *  the widget.  Queries the current domNode size if necessary.
             * Calls layout() to resize contents (and maybe adjust child widgets).
             * 
             * @param changeSize               OptionalSets the widget to this margin-box size and position.May include any/all of the following properties:{w: int, h: int, l: int, t: int}             
             * @param resultSize               OptionalThe margin-box size of this widget after applying changeSize (ifchangeSize is specified).  If caller knows this size andpasses it in, we don't need to query the browser to get the size.{w: int, h: int}             
             */
            resize(changeSize: Object, resultSize: Object): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Called after all the widgets have been instantiated and their
             * dom nodes have been inserted somewhere under .
             * 
             * Widgets should override this method to do any initialization
             * dependent on other widgets existing, and then call
             * this superclass method to finish things off.
             * 
             * startup() in subclasses shouldn't do anything
             * size related because the size of the widget hasn't been set yet.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/AccordionContainer.html
         *
         * Holds a set of panes where every pane's title is visible, but only one pane's content is visible at a time,
         * and switching between panes is visualized by sliding the other panes up/down.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class AccordionContainer extends dijit.layout.StackContainer {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If true, change the size of my currently displayed child to match my size
             * 
             */
            "doLayout": boolean;
            set(property:"doLayout", value: boolean): void;
            get(property:"doLayout"): boolean;
            watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Amount of time (in ms) it takes to slide panes
             * 
             */
            "duration": number;
            set(property:"duration", value: number): void;
            get(property:"duration"): number;
            watch(property:"duration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Indicates that this widget is going to call resize() on its
             * children widgets, setting their size, when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Remembers the selected child across sessions
             * 
             */
            "persist": boolean;
            set(property:"persist", value: boolean): void;
            get(property:"persist"): boolean;
            watch(property:"persist", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * References the currently selected child widget, if any.
             * Adjust selected child with selectChild() method.
             * 
             */
            "selectedChildWidget": Object;
            set(property:"selectedChildWidget", value: Object): void;
            get(property:"selectedChildWidget"): Object;
            watch(property:"selectedChildWidget", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * @param child             
             * @param insertIndex               Optional            
             */
            addChild(child: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Go back to previous page.
             * 
             */
            back(): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * The name of the widget used to display the title of each pane
             * 
             */
            buttonWidget(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * 
             * @param preserveDom             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Advance to next page.
             * 
             */
            forward(): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * 
             */
            getChildren(): any;
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the index of this widget within its container parent.
             * It returns -1 if the parent does not exist, or if the parent
             * is not a dijit/_Container
             * 
             */
            getIndexInParent(): any;
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns null if this is the last child of the parent,
             * otherwise returns the next element sibling to the "right".
             * 
             */
            getNextSibling(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns null if this is the first child of the parent,
             * otherwise returns the next element sibling to the "left".
             * 
             */
            getPreviousSibling(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            layout(): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * 
             * @param child             
             */
            removeChild(child: any): void;
            /**
             * 
             */
            resize(): void;
            /**
             * Show the given widget (which must be one of my children)
             * 
             * @param page Reference to child widget or id of child widget             
             * @param animate             
             */
            selectChild(page: dijit._WidgetBase , animate: boolean): any;
            /**
             * Show the given widget (which must be one of my children)
             * 
             * @param page Reference to child widget or id of child widget             
             * @param animate             
             */
            selectChild(page: String, animate: boolean): any;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module AccordionContainer {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/AccordionContainer._InnerContainer.html
             *
             * 
             * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
             * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
             */
            class _InnerContainer extends dijit._Widget implements dijit._CssStateMixin {
                constructor(params?: Object, srcNodeRef?: HTMLElement);
                /**
                 * True if mouse was pressed while over this widget, and hasn't been released yet
                 * 
                 */
                "active": boolean;
                set(property:"active", value: boolean): void;
                get(property:"active"): boolean;
                watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                 * for each XXX attribute to be mapped to the DOM.
                 * 
                 * attributeMap sets up a "binding" between attributes (aka properties)
                 * of the widget and the widget's DOM.
                 * Changes to widget attributes listed in attributeMap will be
                 * reflected into the DOM.
                 * 
                 * For example, calling set('title', 'hello')
                 * on a TitlePane will automatically cause the TitlePane's DOM to update
                 * with the new title.
                 * 
                 * attributeMap is a hash where the key is an attribute of the widget,
                 * and the value reflects a binding to a:
                 * 
                 * DOM node attribute
                 *   focus: {node: "focusNode", type: "attribute"}
                 * Maps this.focus to this.focusNode.focus
                 * 
                 * DOM node innerHTML
                 *   title: { node: "titleNode", type: "innerHTML" }
                 * Maps this.title to this.titleNode.innerHTML
                 * 
                 * DOM node innerText
                 *   title: { node: "titleNode", type: "innerText" }
                 * Maps this.title to this.titleNode.innerText
                 * 
                 * DOM node CSS class
                 *   myClass: { node: "domNode", type: "class" }
                 * Maps this.myClass to this.domNode.className
                 * 
                 * If the value is an array, then each element in the array matches one of the
                 * formats of the above list.
                 * 
                 * There are also some shorthands for backwards compatibility:
                 * 
                 * string --> { node: string, type: "attribute" }, for example:
                 * "focusNode" ---> { node: "focusNode", type: "attribute" }
                 * "" --> { node: "domNode", type: "attribute" }
                 * 
                 */
                "attributeMap": Object;
                set(property:"attributeMap", value: Object): void;
                get(property:"attributeMap"): Object;
                watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * 
                 */
                "baseClass": string;
                set(property:"baseClass", value: string): void;
                get(property:"baseClass"): string;
                watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Class to use to instantiate title
                 * (Wish we didn't have a separate widget for just the title but maintaining it
                 * for backwards compatibility, is it worth it?)
                 * 
                 */
                "buttonWidget": Function;
                set(property:"buttonWidget", value: Function): void;
                get(property:"buttonWidget"): Function;
                watch(property:"buttonWidget", callback:{(property?:string, oldValue?:Function, newValue?: Function):void}) :{unwatch():void}
                /**
                 * 
                 */
                "class": string;
                set(property:"class", value: string): void;
                get(property:"class"): string;
                watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Designates where children of the source DOM node will be placed.
                 * "Children" in this case refers to both DOM nodes and widgets.
                 * For example, for myWidget:
                 * 
                 * <div data-dojo-type=myWidget>
                 *     <b> here's a plain DOM node
                 *     <span data-dojo-type=subWidget>and a widget</span>
                 *     <i> and another plain DOM node </i>
                 * </div>
                 * containerNode would point to:
                 * 
                 * <b> here's a plain DOM node
                 * <span data-dojo-type=subWidget>and a widget</span>
                 * <i> and another plain DOM node </i>
                 * In templated widgets, "containerNode" is set via a
                 * data-dojo-attach-point assignment.
                 * 
                 * containerNode must be defined for any widget that accepts innerHTML
                 * (like ContentPane or BorderContainer or even Button), and conversely
                 * is null for widgets that don't, like TextBox.
                 * 
                 */
                "containerNode": HTMLElement;
                set(property:"containerNode", value: HTMLElement): void;
                get(property:"containerNode"): HTMLElement;
                watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * Pointer to the real child widget
                 * 
                 */
                "contentWidget": Object;
                set(property:"contentWidget", value: Object): void;
                get(property:"contentWidget"): Object;
                watch(property:"contentWidget", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
                 * need CSS classes applied on mouse hover/press and focus.
                 * 
                 * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
                 * (like "dijitUpArrowButton"). Example:
                 * 
                 * {
                 *     "upArrowButton": "dijitUpArrowButton",
                 *     "downArrowButton": "dijitDownArrowButton"
                 * }
                 * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
                 * 
                 * is hovered, etc.
                 * 
                 */
                "cssStateNodes": Object;
                set(property:"cssStateNodes", value: Object): void;
                get(property:"cssStateNodes"): Object;
                watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Bi-directional support, as defined by the HTML DIR
                 * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                 * default direction.
                 * 
                 */
                "dir": string;
                set(property:"dir", value: string): void;
                get(property:"dir"): string;
                watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This is our visible representation of the widget! Other DOM
                 * Nodes may by assigned to other properties, usually through the
                 * template system's data-dojo-attach-point syntax, but the domNode
                 * property is the canonical "top level" node in widget UI.
                 * 
                 */
                "domNode": HTMLElement;
                set(property:"domNode", value: HTMLElement): void;
                get(property:"domNode"): HTMLElement;
                watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * This widget or a widget it contains has focus, or is "active" because
                 * it was recently clicked.
                 * 
                 */
                "focused": boolean;
                set(property:"focused", value: boolean): void;
                get(property:"focused"): boolean;
                watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * True if cursor is over this widget
                 * 
                 */
                "hovering": boolean;
                set(property:"hovering", value: boolean): void;
                get(property:"hovering"): boolean;
                watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * A unique, opaque ID string that can be assigned by users or by the
                 * system. If the developer passes an ID which is known not to be
                 * unique, the specified ID is ignored and the system-generated ID is
                 * used instead.
                 * 
                 */
                "id": string;
                set(property:"id", value: string): void;
                get(property:"id"): string;
                watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "isLayoutContainer": boolean;
                set(property:"isLayoutContainer", value: boolean): void;
                get(property:"isLayoutContainer"): boolean;
                watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Rarely used.  Overrides the default Dojo locale used to render this widget,
                 * as defined by the HTML LANG attribute.
                 * Value must be among the list of locales specified during by the Dojo bootstrap,
                 * formatted according to RFC 3066 (like en-us).
                 * 
                 */
                "lang": string;
                set(property:"lang", value: string): void;
                get(property:"lang"): string;
                watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * The document this widget belongs to.  If not specified to constructor, will default to
                 * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                 * 
                 */
                "ownerDocument": Object;
                set(property:"ownerDocument", value: Object): void;
                get(property:"ownerDocument"): Object;
                watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * pointer to original DOM node
                 * 
                 */
                "srcNodeRef": HTMLElement;
                set(property:"srcNodeRef", value: HTMLElement): void;
                get(property:"srcNodeRef"): HTMLElement;
                watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * HTML style attributes as cssText string or name/value hash
                 * 
                 */
                "style": string;
                set(property:"style", value: string): void;
                get(property:"style"): string;
                watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * HTML title attribute.
                 * 
                 * For form widgets this specifies a tooltip to display when hovering over
                 * the widget (just like the native HTML title attribute).
                 * 
                 * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                 * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                 * interpreted as HTML.
                 * 
                 */
                "title": string;
                set(property:"title", value: string): void;
                get(property:"title"): string;
                watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                 * this specifies the tooltip to appear when the mouse is hovered over that text.
                 * 
                 */
                "tooltip": string;
                set(property:"tooltip", value: string): void;
                get(property:"tooltip"): string;
                watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: String, value: Object): any;
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: Object, value: Object): any;
                /**
                 * 
                 */
                buildRendering(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: Function): any;
                /**
                 * Wrapper to setTimeout to avoid deferred functions executing
                 * after the originating widget has been destroyed.
                 * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                 * 
                 * @param fcn Function reference.             
                 * @param delay               OptionalDelay, defaults to 0.             
                 */
                defer(fcn: Function, delay: number): Object;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * 
                 * @param preserveDom             
                 */
                destroyDescendants(preserveDom?: boolean): void;
                /**
                 * Destroy this widget and its descendants
                 * This is the generic "destructor" function that all widget users
                 * should call to cleanly discard with a widget. Once a widget is
                 * destroyed, it is removed from the manager object.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                 */
                destroyRecursive(preserveDom?: boolean): void;
                /**
                 * Destroys the DOM nodes associated with this widget.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                 */
                destroyRendering(preserveDom?: boolean): void;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Disconnects handle created by connect.
                 * 
                 * @param handle             
                 */
                disconnect(handle: any): void;
                /**
                 * Used by widgets to signal that a synthetic event occurred, ex:
                 * 
                 * myWidget.emit("attrmodified-selectedChildWidget", {}).
                 * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                 * Also calls onType() method, if present, and returns value from that method.
                 * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                 * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                 * 
                 * @param type             
                 * @param eventObj               Optional            
                 * @param callbackArgs               Optional            
                 */
                emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                /**
                 * Get a property from a widget.
                 * Get a named property from a widget. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _getFooAttr(), calling:
                 * myWidget.get("foo") would be equivalent to calling
                 * widget._getFooAttr() and myWidget.get("bar")
                 * would be equivalent to the expression
                 * widget.bar2
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                 * is this widget.   Note that it does not return all descendants, but rather just direct children.
                 * Analogous to Node.childNodes,
                 * except containing widgets rather than DOMNodes.
                 * 
                 * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                 * outside of this.containerNode.
                 * 
                 * Note that the array returned is a simple array.  Application code should not assume
                 * existence of methods like forEach().
                 * 
                 */
                getChildren(): any[];
                /**
                 * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                 * This method should generally be avoided as it returns widgets declared in templates, which are
                 * supposed to be internal/hidden, but it's left here for back-compat reasons.
                 * 
                 */
                getDescendants(): any[];
                /**
                 * Returns the parent widget of this widget.
                 * 
                 */
                getParent(): any;
                /**
                 * Return true if this widget can currently be focused
                 * and false if not
                 * 
                 */
                isFocusable(): any;
                /**
                 * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                 * 
                 */
                isLeftToRight(): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: String, func: Function): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: Function, func: Function): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: number): any;
                /**
                 * 
                 */
                postCreate(): void;
                /**
                 * Called after the parameters to the widget have been read-in,
                 * but before the widget template is instantiated. Especially
                 * useful to set properties that are referenced in the widget
                 * template.
                 * 
                 */
                postMixInProperties(): void;
                /**
                 * Set a property on a widget
                 * Sets named properties on a widget which may potentially be handled by a
                 * setter in the widget.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _setFooAttr(), calling
                 * myWidget.set("foo", "Howdy!") would be equivalent to calling
                 * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                 * would be equivalent to the statement widget.bar = 3;
                 * 
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * myWidget.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * });
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: any, value: any): any;
                /**
                 * Deprecated.  Use set() instead.
                 * 
                 * @param attr             
                 * @param value             
                 */
                setAttribute(attr: String, value: any): void;
                /**
                 * 
                 */
                startup(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                 * 
                 * Subscribes to the specified topic and calls the specified method
                 * of this object and registers for unsubscribe() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.subscribe, except with the
                 * implicit use of this widget as the target object.
                 * 
                 * @param t The topic             
                 * @param method The callback             
                 */
                subscribe(t: String, method: Function): any;
                /**
                 * Returns a string that represents the widget.
                 * When a widget is cast to a string, this method will be used to generate the
                 * output. Currently, it does not implement any sort of reversible
                 * serialization.
                 * 
                 */
                toString(): string;
                /**
                 * Deprecated. Override destroy() instead to implement custom widget tear-down
                 * behavior.
                 * 
                 */
                uninitialize(): boolean;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Unsubscribes handle created by this.subscribe.
                 * Also removes handle from this widget's list of subscriptions
                 * 
                 * @param handle             
                 */
                unsubscribe(handle: Object): void;
                /**
                 * Watches a property for changes
                 * 
                 * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                 * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                 */
                watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                /**
                 * Called when the widget stops being "active" because
                 * focus moved to something outside of it, or the user
                 * clicked somewhere outside of it, or the widget was
                 * hidden.
                 * 
                 */
                onBlur(): void;
                /**
                 * Connect to this function to receive notifications of mouse click events.
                 * 
                 * @param event mouse Event             
                 */
                onClick(event: any): void;
                /**
                 * Called when this widget is being displayed as a popup (ex: a Calendar popped
                 * up from a DateTextBox), and it is hidden.
                 * This is called from the dijit.popup code, and should not be called directly.
                 * 
                 * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                 * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                 * 
                 */
                onClose(): boolean;
                /**
                 * Connect to this function to receive notifications of mouse double click events.
                 * 
                 * @param event mouse Event             
                 */
                onDblClick(event: any): void;
                /**
                 * Called when the widget becomes "active" because
                 * it or a widget inside of it either has focus, or has recently
                 * been clicked.
                 * 
                 */
                onFocus(): void;
                /**
                 * Called when another widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onHide(): void;
                /**
                 * Connect to this function to receive notifications of keys being pressed down.
                 * 
                 * @param event key Event             
                 */
                onKeyDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of printable keys being typed.
                 * 
                 * @param event key Event             
                 */
                onKeyPress(event: any): void;
                /**
                 * Connect to this function to receive notifications of keys being released.
                 * 
                 * @param event key Event             
                 */
                onKeyUp(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is pressed down.
                 * 
                 * @param event mouse Event             
                 */
                onMouseDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseEnter(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseLeave(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseMove(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOut(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOver(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is released.
                 * 
                 * @param event mouse Event             
                 */
                onMouseUp(event: any): void;
                /**
                 * Called when this widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onShow(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/AccordionContainer._Button.html
             *
             * The title bar to click to open up an accordion pane.
             * Internal widget used by AccordionContainer.
             * 
             * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
             * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
             */
            class _Button extends dijit._Widget implements dijit._TemplatedMixin, dijit._CssStateMixin {
                constructor(params?: Object, srcNodeRef?: HTMLElement);
                /**
                 * True if mouse was pressed while over this widget, and hasn't been released yet
                 * 
                 */
                "active": boolean;
                set(property:"active", value: boolean): void;
                get(property:"active"): boolean;
                watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Object to which attach points and events will be scoped.  Defaults
                 * to 'this'.
                 * 
                 */
                "attachScope": Object;
                set(property:"attachScope", value: Object): void;
                get(property:"attachScope"): Object;
                watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                 * for each XXX attribute to be mapped to the DOM.
                 * 
                 * attributeMap sets up a "binding" between attributes (aka properties)
                 * of the widget and the widget's DOM.
                 * Changes to widget attributes listed in attributeMap will be
                 * reflected into the DOM.
                 * 
                 * For example, calling set('title', 'hello')
                 * on a TitlePane will automatically cause the TitlePane's DOM to update
                 * with the new title.
                 * 
                 * attributeMap is a hash where the key is an attribute of the widget,
                 * and the value reflects a binding to a:
                 * 
                 * DOM node attribute
                 *   focus: {node: "focusNode", type: "attribute"}
                 * Maps this.focus to this.focusNode.focus
                 * 
                 * DOM node innerHTML
                 *   title: { node: "titleNode", type: "innerHTML" }
                 * Maps this.title to this.titleNode.innerHTML
                 * 
                 * DOM node innerText
                 *   title: { node: "titleNode", type: "innerText" }
                 * Maps this.title to this.titleNode.innerText
                 * 
                 * DOM node CSS class
                 *   myClass: { node: "domNode", type: "class" }
                 * Maps this.myClass to this.domNode.className
                 * 
                 * If the value is an array, then each element in the array matches one of the
                 * formats of the above list.
                 * 
                 * There are also some shorthands for backwards compatibility:
                 * 
                 * string --> { node: string, type: "attribute" }, for example:
                 * "focusNode" ---> { node: "focusNode", type: "attribute" }
                 * "" --> { node: "domNode", type: "attribute" }
                 * 
                 */
                "attributeMap": Object;
                set(property:"attributeMap", value: Object): void;
                get(property:"attributeMap"): Object;
                watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * 
                 */
                "baseClass": string;
                set(property:"baseClass", value: string): void;
                get(property:"baseClass"): string;
                watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "class": string;
                set(property:"class", value: string): void;
                get(property:"class"): string;
                watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Designates where children of the source DOM node will be placed.
                 * "Children" in this case refers to both DOM nodes and widgets.
                 * For example, for myWidget:
                 * 
                 * <div data-dojo-type=myWidget>
                 *     <b> here's a plain DOM node
                 *     <span data-dojo-type=subWidget>and a widget</span>
                 *     <i> and another plain DOM node </i>
                 * </div>
                 * containerNode would point to:
                 * 
                 * <b> here's a plain DOM node
                 * <span data-dojo-type=subWidget>and a widget</span>
                 * <i> and another plain DOM node </i>
                 * In templated widgets, "containerNode" is set via a
                 * data-dojo-attach-point assignment.
                 * 
                 * containerNode must be defined for any widget that accepts innerHTML
                 * (like ContentPane or BorderContainer or even Button), and conversely
                 * is null for widgets that don't, like TextBox.
                 * 
                 */
                "containerNode": HTMLElement;
                set(property:"containerNode", value: HTMLElement): void;
                get(property:"containerNode"): HTMLElement;
                watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
                 * need CSS classes applied on mouse hover/press and focus.
                 * 
                 * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
                 * (like "dijitUpArrowButton"). Example:
                 * 
                 * {
                 *     "upArrowButton": "dijitUpArrowButton",
                 *     "downArrowButton": "dijitDownArrowButton"
                 * }
                 * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
                 * 
                 * is hovered, etc.
                 * 
                 */
                "cssStateNodes": Object;
                set(property:"cssStateNodes", value: Object): void;
                get(property:"cssStateNodes"): Object;
                watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Bi-directional support, as defined by the HTML DIR
                 * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                 * default direction.
                 * 
                 */
                "dir": string;
                set(property:"dir", value: string): void;
                get(property:"dir"): string;
                watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This is our visible representation of the widget! Other DOM
                 * Nodes may by assigned to other properties, usually through the
                 * template system's data-dojo-attach-point syntax, but the domNode
                 * property is the canonical "top level" node in widget UI.
                 * 
                 */
                "domNode": HTMLElement;
                set(property:"domNode", value: HTMLElement): void;
                get(property:"domNode"): HTMLElement;
                watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * This widget or a widget it contains has focus, or is "active" because
                 * it was recently clicked.
                 * 
                 */
                "focused": boolean;
                set(property:"focused", value: boolean): void;
                get(property:"focused"): boolean;
                watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * True if cursor is over this widget
                 * 
                 */
                "hovering": boolean;
                set(property:"hovering", value: boolean): void;
                get(property:"hovering"): boolean;
                watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * CSS class for icon to left of label
                 * 
                 */
                "iconClassAttr": string;
                set(property:"iconClassAttr", value: string): void;
                get(property:"iconClassAttr"): string;
                watch(property:"iconClassAttr", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * A unique, opaque ID string that can be assigned by users or by the
                 * system. If the developer passes an ID which is known not to be
                 * unique, the specified ID is ignored and the system-generated ID is
                 * used instead.
                 * 
                 */
                "id": string;
                set(property:"id", value: string): void;
                get(property:"id"): string;
                watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Title of the pane
                 * 
                 */
                "label": string;
                set(property:"label", value: string): void;
                get(property:"label"): string;
                watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Rarely used.  Overrides the default Dojo locale used to render this widget,
                 * as defined by the HTML LANG attribute.
                 * Value must be among the list of locales specified during by the Dojo bootstrap,
                 * formatted according to RFC 3066 (like en-us).
                 * 
                 */
                "lang": string;
                set(property:"lang", value: string): void;
                get(property:"lang"): string;
                watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * The document this widget belongs to.  If not specified to constructor, will default to
                 * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                 * 
                 */
                "ownerDocument": Object;
                set(property:"ownerDocument", value: Object): void;
                get(property:"ownerDocument"): Object;
                watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * 
                 */
                "searchContainerNode": boolean;
                set(property:"searchContainerNode", value: boolean): void;
                get(property:"searchContainerNode"): boolean;
                watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * pointer to original DOM node
                 * 
                 */
                "srcNodeRef": HTMLElement;
                set(property:"srcNodeRef", value: HTMLElement): void;
                get(property:"srcNodeRef"): HTMLElement;
                watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * HTML style attributes as cssText string or name/value hash
                 * 
                 */
                "style": string;
                set(property:"style", value: string): void;
                get(property:"style"): string;
                watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                 * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                 * 
                 */
                "templatePath": string;
                set(property:"templatePath", value: string): void;
                get(property:"templatePath"): string;
                watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "templateString": string;
                set(property:"templateString", value: string): void;
                get(property:"templateString"): string;
                watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Tooltip that appears on hover
                 * 
                 */
                "title": string;
                set(property:"title", value: string): void;
                get(property:"title"): string;
                watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                 * this specifies the tooltip to appear when the mouse is hovered over that text.
                 * 
                 */
                "tooltip": string;
                set(property:"tooltip", value: string): void;
                get(property:"tooltip"): string;
                watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: String, value: Object): any;
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: Object, value: Object): any;
                /**
                 * 
                 */
                buildRendering(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: Function): any;
                /**
                 * Wrapper to setTimeout to avoid deferred functions executing
                 * after the originating widget has been destroyed.
                 * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                 * 
                 * @param fcn Function reference.             
                 * @param delay               OptionalDelay, defaults to 0.             
                 */
                defer(fcn: Function, delay: number): Object;
                /**
                 * Destroy this widget, but not its descendants.  Descendants means widgets inside of
                 * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
                 * 
                 * This method will also destroy internal widgets such as those created from a template,
                 * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
                 * 
                 * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
                 * depend on the current ability to destroy a widget without destroying its descendants.   Generally
                 * they should use destroyRecursive() for widgets with children.
                 * 
                 * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
                 */
                destroy(preserveDom?: boolean): void;
                /**
                 * Recursively destroy the children of this widget and their
                 * descendants.
                 * 
                 * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                 */
                destroyDescendants(preserveDom?: boolean): void;
                /**
                 * Destroy this widget and its descendants
                 * This is the generic "destructor" function that all widget users
                 * should call to cleanly discard with a widget. Once a widget is
                 * destroyed, it is removed from the manager object.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                 */
                destroyRecursive(preserveDom?: boolean): void;
                /**
                 * Destroys the DOM nodes associated with this widget.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                 */
                destroyRendering(preserveDom?: boolean): void;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Disconnects handle created by connect.
                 * 
                 * @param handle             
                 */
                disconnect(handle: any): void;
                /**
                 * Used by widgets to signal that a synthetic event occurred, ex:
                 * 
                 * myWidget.emit("attrmodified-selectedChildWidget", {}).
                 * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                 * Also calls onType() method, if present, and returns value from that method.
                 * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                 * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                 * 
                 * @param type             
                 * @param eventObj               Optional            
                 * @param callbackArgs               Optional            
                 */
                emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                /**
                 * Get a property from a widget.
                 * Get a named property from a widget. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _getFooAttr(), calling:
                 * myWidget.get("foo") would be equivalent to calling
                 * widget._getFooAttr() and myWidget.get("bar")
                 * would be equivalent to the expression
                 * widget.bar2
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                 * is this widget.   Note that it does not return all descendants, but rather just direct children.
                 * Analogous to Node.childNodes,
                 * except containing widgets rather than DOMNodes.
                 * 
                 * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                 * outside of this.containerNode.
                 * 
                 * Note that the array returned is a simple array.  Application code should not assume
                 * existence of methods like forEach().
                 * 
                 */
                getChildren(): any[];
                /**
                 * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                 * This method should generally be avoided as it returns widgets declared in templates, which are
                 * supposed to be internal/hidden, but it's left here for back-compat reasons.
                 * 
                 */
                getDescendants(): any[];
                /**
                 * Returns the height of the title dom node.
                 * 
                 */
                getTitleHeight(): any;
                /**
                 * Return true if this widget can currently be focused
                 * and false if not
                 * 
                 */
                isFocusable(): any;
                /**
                 * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                 * 
                 */
                isLeftToRight(): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: String, func: Function): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: Function, func: Function): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: number): any;
                /**
                 * 
                 */
                postCreate(): void;
                /**
                 * Called after the parameters to the widget have been read-in,
                 * but before the widget template is instantiated. Especially
                 * useful to set properties that are referenced in the widget
                 * template.
                 * 
                 */
                postMixInProperties(): void;
                /**
                 * Set a property on a widget
                 * Sets named properties on a widget which may potentially be handled by a
                 * setter in the widget.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _setFooAttr(), calling
                 * myWidget.set("foo", "Howdy!") would be equivalent to calling
                 * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                 * would be equivalent to the statement widget.bar = 3;
                 * 
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * myWidget.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * });
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: any, value: any): any;
                /**
                 * Deprecated.  Use set() instead.
                 * 
                 * @param attr             
                 * @param value             
                 */
                setAttribute(attr: String, value: any): void;
                /**
                 * Processing after the DOM fragment is added to the document
                 * Called after a widget and its children have been created and added to the page,
                 * and all related widgets have finished their create() cycle, up through postCreate().
                 * 
                 * Note that startup() may be called while the widget is still hidden, for example if the widget is
                 * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
                 * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
                 * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
                 * 
                 */
                startup(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                 * 
                 * Subscribes to the specified topic and calls the specified method
                 * of this object and registers for unsubscribe() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.subscribe, except with the
                 * implicit use of this widget as the target object.
                 * 
                 * @param t The topic             
                 * @param method The callback             
                 */
                subscribe(t: String, method: Function): any;
                /**
                 * Returns a string that represents the widget.
                 * When a widget is cast to a string, this method will be used to generate the
                 * output. Currently, it does not implement any sort of reversible
                 * serialization.
                 * 
                 */
                toString(): string;
                /**
                 * Deprecated. Override destroy() instead to implement custom widget tear-down
                 * behavior.
                 * 
                 */
                uninitialize(): boolean;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Unsubscribes handle created by this.subscribe.
                 * Also removes handle from this widget's list of subscriptions
                 * 
                 * @param handle             
                 */
                unsubscribe(handle: Object): void;
                /**
                 * Watches a property for changes
                 * 
                 * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                 * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                 */
                watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                /**
                 * Static method to get a template based on the templatePath or
                 * templateString key
                 */
                getCachedTemplate(): any;
                /**
                 * Called when the widget stops being "active" because
                 * focus moved to something outside of it, or the user
                 * clicked somewhere outside of it, or the widget was
                 * hidden.
                 * 
                 */
                onBlur(): void;
                /**
                 * Connect to this function to receive notifications of mouse click events.
                 * 
                 * @param event mouse Event             
                 */
                onClick(event: any): void;
                /**
                 * Called when this widget is being displayed as a popup (ex: a Calendar popped
                 * up from a DateTextBox), and it is hidden.
                 * This is called from the dijit.popup code, and should not be called directly.
                 * 
                 * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                 * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                 * 
                 */
                onClose(): boolean;
                /**
                 * Connect to this function to receive notifications of mouse double click events.
                 * 
                 * @param event mouse Event             
                 */
                onDblClick(event: any): void;
                /**
                 * Called when the widget becomes "active" because
                 * it or a widget inside of it either has focus, or has recently
                 * been clicked.
                 * 
                 */
                onFocus(): void;
                /**
                 * Called when another widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onHide(): void;
                /**
                 * Connect to this function to receive notifications of keys being pressed down.
                 * 
                 * @param event key Event             
                 */
                onKeyDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of printable keys being typed.
                 * 
                 * @param event key Event             
                 */
                onKeyPress(event: any): void;
                /**
                 * Connect to this function to receive notifications of keys being released.
                 * 
                 * @param event key Event             
                 */
                onKeyUp(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is pressed down.
                 * 
                 * @param event mouse Event             
                 */
                onMouseDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseEnter(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseLeave(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseMove(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOut(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOver(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is released.
                 * 
                 * @param event mouse Event             
                 */
                onMouseUp(event: any): void;
                /**
                 * Called when this widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onShow(): void;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/_TabContainerBase.html
         *
         * Abstract base class for TabContainer.   Must define _makeController() to instantiate
         * and return the widget that displays the tab labels
         * A TabContainer is a container that has multiple panes, but shows only
         * one pane at a time.  There are a set of tabs corresponding to each pane,
         * where each tab has the name (aka title) of the pane, and optionally a close button.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class _TabContainerBase extends dijit.layout.StackContainer implements dijit._TemplatedMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If true, change the size of my currently displayed child to match my size
             * 
             */
            "doLayout": boolean;
            set(property:"doLayout", value: boolean): void;
            get(property:"doLayout"): boolean;
            watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Indicates that this widget is going to call resize() on its
             * children widgets, setting their size, when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 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;
            set(property:"nested", value: boolean): void;
            get(property:"nested"): boolean;
            watch(property:"nested", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Remembers the selected child across sessions
             * 
             */
            "persist": boolean;
            set(property:"persist", value: boolean): void;
            get(property:"persist"): boolean;
            watch(property:"persist", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * References the currently selected child widget, if any.
             * Adjust selected child with selectChild() method.
             * 
             */
            "selectedChildWidget": Object;
            set(property:"selectedChildWidget", value: Object): void;
            get(property:"selectedChildWidget"): Object;
            watch(property:"selectedChildWidget", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines where tabs go relative to tab content.
             * "top", "bottom", "left-h", "right-h"
             * 
             */
            "tabPosition": string;
            set(property:"tabPosition", value: string): void;
            get(property:"tabPosition"): string;
            watch(property:"tabPosition", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 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;
            set(property:"tabStrip", value: boolean): void;
            get(property:"tabStrip"): boolean;
            watch(property:"tabStrip", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * @param child             
             * @param insertIndex               Optional            
             */
            addChild(child: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Go back to previous page.
             * 
             */
            back(): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             * @param preserveDom             
             */
            destroy(preserveDom?: any): void;
            /**
             * 
             * @param preserveDom             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Advance to next page.
             * 
             */
            forward(): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the index of this widget within its container parent.
             * It returns -1 if the parent does not exist, or if the parent
             * is not a dijit/_Container
             * 
             */
            getIndexInParent(): any;
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns null if this is the last child of the parent,
             * otherwise returns the next element sibling to the "right".
             * 
             */
            getNextSibling(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns null if this is the first child of the parent,
             * otherwise returns the next element sibling to the "left".
             * 
             */
            getPreviousSibling(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            layout(): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * 
             */
            resize(): void;
            /**
             * Show the given widget (which must be one of my children)
             * 
             * @param page Reference to child widget or id of child widget             
             * @param animate             
             */
            selectChild(page: dijit._WidgetBase , animate: boolean): any;
            /**
             * Show the given widget (which must be one of my children)
             * 
             * @param page Reference to child widget or id of child widget             
             * @param animate             
             */
            selectChild(page: String, animate: boolean): any;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/BorderContainer.html
         *
         * A BorderContainer is a dijit/LayoutContainer that can have draggable splitters between the children,
         * in order to adjust their sizes.
         * 
         * In addition, it automatically adds some space between the children even
         * if they don't have a draggable splitter between them, and space between the edge of the BorderContainer
         * and the children that are adjacent to the edge.  Note that the intended style is that all the children
         * have borders, but (despite the name) the BorderContainer itself does not.
         * 
         * See BorderContainer.ChildWidgetProperties for details on the properties that can be set on
         * children of a BorderContainer.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class BorderContainer extends dijit.layout.LayoutContainer {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * These properties can be specified for the children of a BorderContainer.
             * 
             */
            "ChildWidgetProperties": Object;
            set(property:"ChildWidgetProperties", value: Object): void;
            get(property:"ChildWidgetProperties"): Object;
            watch(property:"ChildWidgetProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 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.
             * 
             */
            "design": string;
            set(property:"design", value: string): void;
            get(property:"design"): string;
            watch(property:"design", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 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;
            set(property:"gutters", value: boolean): void;
            get(property:"gutters"): boolean;
            watch(property:"gutters", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Indicates that this widget is going to call resize() on its
             * children widgets, setting their size, when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Specifies whether splitters resize as you drag (true) or only upon mouseup (false)
             * 
             */
            "liveSplitters": boolean;
            set(property:"liveSplitters", value: boolean): void;
            get(property:"liveSplitters"): boolean;
            watch(property:"liveSplitters", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Save splitter positions in a cookie.
             * 
             */
            "persist": boolean;
            set(property:"persist", value: boolean): void;
            get(property:"persist"): boolean;
            watch(property:"persist", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * @param child             
             * @param insertIndex               Optional            
             */
            addChild(child: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * 
             */
            destroyRecursive(): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * 
             */
            getChildren(): any;
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the index of this widget within its container parent.
             * It returns -1 if the parent does not exist, or if the parent
             * is not a dijit/_Container
             * 
             */
            getIndexInParent(): any;
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns null if this is the last child of the parent,
             * otherwise returns the next element sibling to the "right".
             * 
             */
            getNextSibling(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns null if this is the first child of the parent,
             * otherwise returns the next element sibling to the "left".
             * 
             */
            getPreviousSibling(): any;
            /**
             * Returns the widget responsible for rendering the splitter associated with region
             * 
             * @param region             
             */
            getSplitter(region: String): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            layout(): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * 
             * @param newSize             
             * @param currentSize             
             */
            resize(newSize: any, currentSize: any): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module BorderContainer {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/BorderContainer._Gutter.html
             *
             * Just a spacer div to separate side pane from center pane.
             * Basically a trick to lookup the gutter/splitter width from the theme.
             * Instantiated by dijit/layout/BorderContainer.  Users should not
             * create directly.
             * 
             * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
             * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
             */
            class _Gutter extends dijit._Widget implements dijit._TemplatedMixin {
                constructor(params?: Object, srcNodeRef?: HTMLElement);
                /**
                 * Object to which attach points and events will be scoped.  Defaults
                 * to 'this'.
                 * 
                 */
                "attachScope": Object;
                set(property:"attachScope", value: Object): void;
                get(property:"attachScope"): Object;
                watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                 * for each XXX attribute to be mapped to the DOM.
                 * 
                 * attributeMap sets up a "binding" between attributes (aka properties)
                 * of the widget and the widget's DOM.
                 * Changes to widget attributes listed in attributeMap will be
                 * reflected into the DOM.
                 * 
                 * For example, calling set('title', 'hello')
                 * on a TitlePane will automatically cause the TitlePane's DOM to update
                 * with the new title.
                 * 
                 * attributeMap is a hash where the key is an attribute of the widget,
                 * and the value reflects a binding to a:
                 * 
                 * DOM node attribute
                 *   focus: {node: "focusNode", type: "attribute"}
                 * Maps this.focus to this.focusNode.focus
                 * 
                 * DOM node innerHTML
                 *   title: { node: "titleNode", type: "innerHTML" }
                 * Maps this.title to this.titleNode.innerHTML
                 * 
                 * DOM node innerText
                 *   title: { node: "titleNode", type: "innerText" }
                 * Maps this.title to this.titleNode.innerText
                 * 
                 * DOM node CSS class
                 *   myClass: { node: "domNode", type: "class" }
                 * Maps this.myClass to this.domNode.className
                 * 
                 * If the value is an array, then each element in the array matches one of the
                 * formats of the above list.
                 * 
                 * There are also some shorthands for backwards compatibility:
                 * 
                 * string --> { node: string, type: "attribute" }, for example:
                 * "focusNode" ---> { node: "focusNode", type: "attribute" }
                 * "" --> { node: "domNode", type: "attribute" }
                 * 
                 */
                "attributeMap": Object;
                set(property:"attributeMap", value: Object): void;
                get(property:"attributeMap"): Object;
                watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
                 * widget state.
                 * 
                 */
                "baseClass": string;
                set(property:"baseClass", value: string): void;
                get(property:"baseClass"): string;
                watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "class": string;
                set(property:"class", value: string): void;
                get(property:"class"): string;
                watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Designates where children of the source DOM node will be placed.
                 * "Children" in this case refers to both DOM nodes and widgets.
                 * For example, for myWidget:
                 * 
                 * <div data-dojo-type=myWidget>
                 *     <b> here's a plain DOM node
                 *     <span data-dojo-type=subWidget>and a widget</span>
                 *     <i> and another plain DOM node </i>
                 * </div>
                 * containerNode would point to:
                 * 
                 * <b> here's a plain DOM node
                 * <span data-dojo-type=subWidget>and a widget</span>
                 * <i> and another plain DOM node </i>
                 * In templated widgets, "containerNode" is set via a
                 * data-dojo-attach-point assignment.
                 * 
                 * containerNode must be defined for any widget that accepts innerHTML
                 * (like ContentPane or BorderContainer or even Button), and conversely
                 * is null for widgets that don't, like TextBox.
                 * 
                 */
                "containerNode": HTMLElement;
                set(property:"containerNode", value: HTMLElement): void;
                get(property:"containerNode"): HTMLElement;
                watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * Bi-directional support, as defined by the HTML DIR
                 * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                 * default direction.
                 * 
                 */
                "dir": string;
                set(property:"dir", value: string): void;
                get(property:"dir"): string;
                watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This is our visible representation of the widget! Other DOM
                 * Nodes may by assigned to other properties, usually through the
                 * template system's data-dojo-attach-point syntax, but the domNode
                 * property is the canonical "top level" node in widget UI.
                 * 
                 */
                "domNode": HTMLElement;
                set(property:"domNode", value: HTMLElement): void;
                get(property:"domNode"): HTMLElement;
                watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * This widget or a widget it contains has focus, or is "active" because
                 * it was recently clicked.
                 * 
                 */
                "focused": boolean;
                set(property:"focused", value: boolean): void;
                get(property:"focused"): boolean;
                watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * A unique, opaque ID string that can be assigned by users or by the
                 * system. If the developer passes an ID which is known not to be
                 * unique, the specified ID is ignored and the system-generated ID is
                 * used instead.
                 * 
                 */
                "id": string;
                set(property:"id", value: string): void;
                get(property:"id"): string;
                watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Rarely used.  Overrides the default Dojo locale used to render this widget,
                 * as defined by the HTML LANG attribute.
                 * Value must be among the list of locales specified during by the Dojo bootstrap,
                 * formatted according to RFC 3066 (like en-us).
                 * 
                 */
                "lang": string;
                set(property:"lang", value: string): void;
                get(property:"lang"): string;
                watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * The document this widget belongs to.  If not specified to constructor, will default to
                 * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                 * 
                 */
                "ownerDocument": Object;
                set(property:"ownerDocument", value: Object): void;
                get(property:"ownerDocument"): Object;
                watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * 
                 */
                "searchContainerNode": boolean;
                set(property:"searchContainerNode", value: boolean): void;
                get(property:"searchContainerNode"): boolean;
                watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * pointer to original DOM node
                 * 
                 */
                "srcNodeRef": HTMLElement;
                set(property:"srcNodeRef", value: HTMLElement): void;
                get(property:"srcNodeRef"): HTMLElement;
                watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * HTML style attributes as cssText string or name/value hash
                 * 
                 */
                "style": string;
                set(property:"style", value: string): void;
                get(property:"style"): string;
                watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                 * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                 * 
                 */
                "templatePath": string;
                set(property:"templatePath", value: string): void;
                get(property:"templatePath"): string;
                watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "templateString": string;
                set(property:"templateString", value: string): void;
                get(property:"templateString"): string;
                watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * HTML title attribute.
                 * 
                 * For form widgets this specifies a tooltip to display when hovering over
                 * the widget (just like the native HTML title attribute).
                 * 
                 * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                 * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                 * interpreted as HTML.
                 * 
                 */
                "title": string;
                set(property:"title", value: string): void;
                get(property:"title"): string;
                watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                 * this specifies the tooltip to appear when the mouse is hovered over that text.
                 * 
                 */
                "tooltip": string;
                set(property:"tooltip", value: string): void;
                get(property:"tooltip"): string;
                watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: String, value: Object): any;
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: Object, value: Object): any;
                /**
                 * 
                 */
                buildRendering(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: Function): any;
                /**
                 * Wrapper to setTimeout to avoid deferred functions executing
                 * after the originating widget has been destroyed.
                 * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                 * 
                 * @param fcn Function reference.             
                 * @param delay               OptionalDelay, defaults to 0.             
                 */
                defer(fcn: Function, delay: number): Object;
                /**
                 * Destroy this widget, but not its descendants.  Descendants means widgets inside of
                 * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
                 * 
                 * This method will also destroy internal widgets such as those created from a template,
                 * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
                 * 
                 * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
                 * depend on the current ability to destroy a widget without destroying its descendants.   Generally
                 * they should use destroyRecursive() for widgets with children.
                 * 
                 * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
                 */
                destroy(preserveDom?: boolean): void;
                /**
                 * Recursively destroy the children of this widget and their
                 * descendants.
                 * 
                 * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                 */
                destroyDescendants(preserveDom?: boolean): void;
                /**
                 * Destroy this widget and its descendants
                 * This is the generic "destructor" function that all widget users
                 * should call to cleanly discard with a widget. Once a widget is
                 * destroyed, it is removed from the manager object.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                 */
                destroyRecursive(preserveDom?: boolean): void;
                /**
                 * Destroys the DOM nodes associated with this widget.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                 */
                destroyRendering(preserveDom?: boolean): void;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Disconnects handle created by connect.
                 * 
                 * @param handle             
                 */
                disconnect(handle: any): void;
                /**
                 * Used by widgets to signal that a synthetic event occurred, ex:
                 * 
                 * myWidget.emit("attrmodified-selectedChildWidget", {}).
                 * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                 * Also calls onType() method, if present, and returns value from that method.
                 * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                 * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                 * 
                 * @param type             
                 * @param eventObj               Optional            
                 * @param callbackArgs               Optional            
                 */
                emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                /**
                 * Get a property from a widget.
                 * Get a named property from a widget. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _getFooAttr(), calling:
                 * myWidget.get("foo") would be equivalent to calling
                 * widget._getFooAttr() and myWidget.get("bar")
                 * would be equivalent to the expression
                 * widget.bar2
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                 * is this widget.   Note that it does not return all descendants, but rather just direct children.
                 * Analogous to Node.childNodes,
                 * except containing widgets rather than DOMNodes.
                 * 
                 * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                 * outside of this.containerNode.
                 * 
                 * Note that the array returned is a simple array.  Application code should not assume
                 * existence of methods like forEach().
                 * 
                 */
                getChildren(): any[];
                /**
                 * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                 * This method should generally be avoided as it returns widgets declared in templates, which are
                 * supposed to be internal/hidden, but it's left here for back-compat reasons.
                 * 
                 */
                getDescendants(): any[];
                /**
                 * Returns the parent widget of this widget.
                 * 
                 */
                getParent(): any;
                /**
                 * Return true if this widget can currently be focused
                 * and false if not
                 * 
                 */
                isFocusable(): any;
                /**
                 * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                 * 
                 */
                isLeftToRight(): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: String, func: Function): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: Function, func: Function): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: number): any;
                /**
                 * 
                 */
                postCreate(): void;
                /**
                 * 
                 */
                postMixInProperties(): void;
                /**
                 * Set a property on a widget
                 * Sets named properties on a widget which may potentially be handled by a
                 * setter in the widget.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _setFooAttr(), calling
                 * myWidget.set("foo", "Howdy!") would be equivalent to calling
                 * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                 * would be equivalent to the statement widget.bar = 3;
                 * 
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * myWidget.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * });
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: any, value: any): any;
                /**
                 * Deprecated.  Use set() instead.
                 * 
                 * @param attr             
                 * @param value             
                 */
                setAttribute(attr: String, value: any): void;
                /**
                 * Processing after the DOM fragment is added to the document
                 * Called after a widget and its children have been created and added to the page,
                 * and all related widgets have finished their create() cycle, up through postCreate().
                 * 
                 * Note that startup() may be called while the widget is still hidden, for example if the widget is
                 * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
                 * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
                 * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
                 * 
                 */
                startup(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                 * 
                 * Subscribes to the specified topic and calls the specified method
                 * of this object and registers for unsubscribe() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.subscribe, except with the
                 * implicit use of this widget as the target object.
                 * 
                 * @param t The topic             
                 * @param method The callback             
                 */
                subscribe(t: String, method: Function): any;
                /**
                 * Returns a string that represents the widget.
                 * When a widget is cast to a string, this method will be used to generate the
                 * output. Currently, it does not implement any sort of reversible
                 * serialization.
                 * 
                 */
                toString(): string;
                /**
                 * Deprecated. Override destroy() instead to implement custom widget tear-down
                 * behavior.
                 * 
                 */
                uninitialize(): boolean;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Unsubscribes handle created by this.subscribe.
                 * Also removes handle from this widget's list of subscriptions
                 * 
                 * @param handle             
                 */
                unsubscribe(handle: Object): void;
                /**
                 * Watches a property for changes
                 * 
                 * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                 * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                 */
                watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                /**
                 * Static method to get a template based on the templatePath or
                 * templateString key
                 */
                getCachedTemplate(): any;
                /**
                 * Called when the widget stops being "active" because
                 * focus moved to something outside of it, or the user
                 * clicked somewhere outside of it, or the widget was
                 * hidden.
                 * 
                 */
                onBlur(): void;
                /**
                 * Connect to this function to receive notifications of mouse click events.
                 * 
                 * @param event mouse Event             
                 */
                onClick(event: any): void;
                /**
                 * Called when this widget is being displayed as a popup (ex: a Calendar popped
                 * up from a DateTextBox), and it is hidden.
                 * This is called from the dijit.popup code, and should not be called directly.
                 * 
                 * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                 * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                 * 
                 */
                onClose(): boolean;
                /**
                 * Connect to this function to receive notifications of mouse double click events.
                 * 
                 * @param event mouse Event             
                 */
                onDblClick(event: any): void;
                /**
                 * Called when the widget becomes "active" because
                 * it or a widget inside of it either has focus, or has recently
                 * been clicked.
                 * 
                 */
                onFocus(): void;
                /**
                 * Called when another widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onHide(): void;
                /**
                 * Connect to this function to receive notifications of keys being pressed down.
                 * 
                 * @param event key Event             
                 */
                onKeyDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of printable keys being typed.
                 * 
                 * @param event key Event             
                 */
                onKeyPress(event: any): void;
                /**
                 * Connect to this function to receive notifications of keys being released.
                 * 
                 * @param event key Event             
                 */
                onKeyUp(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is pressed down.
                 * 
                 * @param event mouse Event             
                 */
                onMouseDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseEnter(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseLeave(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseMove(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOut(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOver(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is released.
                 * 
                 * @param event mouse Event             
                 */
                onMouseUp(event: any): void;
                /**
                 * Called when this widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onShow(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/BorderContainer._Splitter.html
             *
             * A draggable spacer between two items in a dijit/layout/BorderContainer.
             * This is instantiated by dijit/layout/BorderContainer.  Users should not
             * create it directly.
             * 
             */
            class _Splitter extends dijit._Widget implements dijit._TemplatedMixin {
                constructor();
                /**
                 * Object to which attach points and events will be scoped.  Defaults
                 * to 'this'.
                 * 
                 */
                "attachScope": Object;
                set(property:"attachScope", value: Object): void;
                get(property:"attachScope"): Object;
                watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                 * for each XXX attribute to be mapped to the DOM.
                 * 
                 * attributeMap sets up a "binding" between attributes (aka properties)
                 * of the widget and the widget's DOM.
                 * Changes to widget attributes listed in attributeMap will be
                 * reflected into the DOM.
                 * 
                 * For example, calling set('title', 'hello')
                 * on a TitlePane will automatically cause the TitlePane's DOM to update
                 * with the new title.
                 * 
                 * attributeMap is a hash where the key is an attribute of the widget,
                 * and the value reflects a binding to a:
                 * 
                 * DOM node attribute
                 *   focus: {node: "focusNode", type: "attribute"}
                 * Maps this.focus to this.focusNode.focus
                 * 
                 * DOM node innerHTML
                 *   title: { node: "titleNode", type: "innerHTML" }
                 * Maps this.title to this.titleNode.innerHTML
                 * 
                 * DOM node innerText
                 *   title: { node: "titleNode", type: "innerText" }
                 * Maps this.title to this.titleNode.innerText
                 * 
                 * DOM node CSS class
                 *   myClass: { node: "domNode", type: "class" }
                 * Maps this.myClass to this.domNode.className
                 * 
                 * If the value is an array, then each element in the array matches one of the
                 * formats of the above list.
                 * 
                 * There are also some shorthands for backwards compatibility:
                 * 
                 * string --> { node: string, type: "attribute" }, for example:
                 * "focusNode" ---> { node: "focusNode", type: "attribute" }
                 * "" --> { node: "domNode", type: "attribute" }
                 * 
                 */
                "attributeMap": Object;
                set(property:"attributeMap", value: Object): void;
                get(property:"attributeMap"): Object;
                watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
                 * widget state.
                 * 
                 */
                "baseClass": string;
                set(property:"baseClass", value: string): void;
                get(property:"baseClass"): string;
                watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Pointer to the pane associated with this splitter
                 * 
                 */
                "child": Object;
                set(property:"child", value: Object): void;
                get(property:"child"): Object;
                watch(property:"child", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * 
                 */
                "class": string;
                set(property:"class", value: string): void;
                get(property:"class"): string;
                watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Pointer to the parent BorderContainer
                 * 
                 */
                "container": Object;
                set(property:"container", value: Object): void;
                get(property:"container"): Object;
                watch(property:"container", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Designates where children of the source DOM node will be placed.
                 * "Children" in this case refers to both DOM nodes and widgets.
                 * For example, for myWidget:
                 * 
                 * <div data-dojo-type=myWidget>
                 *     <b> here's a plain DOM node
                 *     <span data-dojo-type=subWidget>and a widget</span>
                 *     <i> and another plain DOM node </i>
                 * </div>
                 * containerNode would point to:
                 * 
                 * <b> here's a plain DOM node
                 * <span data-dojo-type=subWidget>and a widget</span>
                 * <i> and another plain DOM node </i>
                 * In templated widgets, "containerNode" is set via a
                 * data-dojo-attach-point assignment.
                 * 
                 * containerNode must be defined for any widget that accepts innerHTML
                 * (like ContentPane or BorderContainer or even Button), and conversely
                 * is null for widgets that don't, like TextBox.
                 * 
                 */
                "containerNode": HTMLElement;
                set(property:"containerNode", value: HTMLElement): void;
                get(property:"containerNode"): HTMLElement;
                watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * Bi-directional support, as defined by the HTML DIR
                 * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                 * default direction.
                 * 
                 */
                "dir": string;
                set(property:"dir", value: string): void;
                get(property:"dir"): string;
                watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This is our visible representation of the widget! Other DOM
                 * Nodes may by assigned to other properties, usually through the
                 * template system's data-dojo-attach-point syntax, but the domNode
                 * property is the canonical "top level" node in widget UI.
                 * 
                 */
                "domNode": HTMLElement;
                set(property:"domNode", value: HTMLElement): void;
                get(property:"domNode"): HTMLElement;
                watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * This widget or a widget it contains has focus, or is "active" because
                 * it was recently clicked.
                 * 
                 */
                "focused": boolean;
                set(property:"focused", value: boolean): void;
                get(property:"focused"): boolean;
                watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * A unique, opaque ID string that can be assigned by users or by the
                 * system. If the developer passes an ID which is known not to be
                 * unique, the specified ID is ignored and the system-generated ID is
                 * used instead.
                 * 
                 */
                "id": string;
                set(property:"id", value: string): void;
                get(property:"id"): string;
                watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Rarely used.  Overrides the default Dojo locale used to render this widget,
                 * as defined by the HTML LANG attribute.
                 * Value must be among the list of locales specified during by the Dojo bootstrap,
                 * formatted according to RFC 3066 (like en-us).
                 * 
                 */
                "lang": string;
                set(property:"lang", value: string): void;
                get(property:"lang"): string;
                watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * If true, the child's size changes and the child widget is redrawn as you drag the splitter;
                 * otherwise, the size doesn't change until you drop the splitter (by mouse-up)
                 * 
                 */
                "live": boolean;
                set(property:"live", value: boolean): void;
                get(property:"live"): boolean;
                watch(property:"live", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * The document this widget belongs to.  If not specified to constructor, will default to
                 * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                 * 
                 */
                "ownerDocument": Object;
                set(property:"ownerDocument", value: Object): void;
                get(property:"ownerDocument"): Object;
                watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Region of pane associated with this splitter.
                 * "top", "bottom", "left", "right".
                 * 
                 */
                "region": string;
                set(property:"region", value: string): void;
                get(property:"region"): string;
                watch(property:"region", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "searchContainerNode": boolean;
                set(property:"searchContainerNode", value: boolean): void;
                get(property:"searchContainerNode"): boolean;
                watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * pointer to original DOM node
                 * 
                 */
                "srcNodeRef": HTMLElement;
                set(property:"srcNodeRef", value: HTMLElement): void;
                get(property:"srcNodeRef"): HTMLElement;
                watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * HTML style attributes as cssText string or name/value hash
                 * 
                 */
                "style": string;
                set(property:"style", value: string): void;
                get(property:"style"): string;
                watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                 * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                 * 
                 */
                "templatePath": string;
                set(property:"templatePath", value: string): void;
                get(property:"templatePath"): string;
                watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "templateString": string;
                set(property:"templateString", value: string): void;
                get(property:"templateString"): string;
                watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * HTML title attribute.
                 * 
                 * For form widgets this specifies a tooltip to display when hovering over
                 * the widget (just like the native HTML title attribute).
                 * 
                 * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                 * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                 * interpreted as HTML.
                 * 
                 */
                "title": string;
                set(property:"title", value: string): void;
                get(property:"title"): string;
                watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                 * this specifies the tooltip to appear when the mouse is hovered over that text.
                 * 
                 */
                "tooltip": string;
                set(property:"tooltip", value: string): void;
                get(property:"tooltip"): string;
                watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: String, value: Object): any;
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: Object, value: Object): any;
                /**
                 * 
                 */
                buildRendering(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: Function): any;
                /**
                 * Wrapper to setTimeout to avoid deferred functions executing
                 * after the originating widget has been destroyed.
                 * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                 * 
                 * @param fcn Function reference.             
                 * @param delay               OptionalDelay, defaults to 0.             
                 */
                defer(fcn: Function, delay: number): Object;
                /**
                 * 
                 */
                destroy(): void;
                /**
                 * Recursively destroy the children of this widget and their
                 * descendants.
                 * 
                 * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                 */
                destroyDescendants(preserveDom?: boolean): void;
                /**
                 * Destroy this widget and its descendants
                 * This is the generic "destructor" function that all widget users
                 * should call to cleanly discard with a widget. Once a widget is
                 * destroyed, it is removed from the manager object.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                 */
                destroyRecursive(preserveDom?: boolean): void;
                /**
                 * Destroys the DOM nodes associated with this widget.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                 */
                destroyRendering(preserveDom?: boolean): void;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Disconnects handle created by connect.
                 * 
                 * @param handle             
                 */
                disconnect(handle: any): void;
                /**
                 * Used by widgets to signal that a synthetic event occurred, ex:
                 * 
                 * myWidget.emit("attrmodified-selectedChildWidget", {}).
                 * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                 * Also calls onType() method, if present, and returns value from that method.
                 * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                 * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                 * 
                 * @param type             
                 * @param eventObj               Optional            
                 * @param callbackArgs               Optional            
                 */
                emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                /**
                 * Get a property from a widget.
                 * Get a named property from a widget. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _getFooAttr(), calling:
                 * myWidget.get("foo") would be equivalent to calling
                 * widget._getFooAttr() and myWidget.get("bar")
                 * would be equivalent to the expression
                 * widget.bar2
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                 * is this widget.   Note that it does not return all descendants, but rather just direct children.
                 * Analogous to Node.childNodes,
                 * except containing widgets rather than DOMNodes.
                 * 
                 * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                 * outside of this.containerNode.
                 * 
                 * Note that the array returned is a simple array.  Application code should not assume
                 * existence of methods like forEach().
                 * 
                 */
                getChildren(): any[];
                /**
                 * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                 * This method should generally be avoided as it returns widgets declared in templates, which are
                 * supposed to be internal/hidden, but it's left here for back-compat reasons.
                 * 
                 */
                getDescendants(): any[];
                /**
                 * Returns the parent widget of this widget.
                 * 
                 */
                getParent(): any;
                /**
                 * Return true if this widget can currently be focused
                 * and false if not
                 * 
                 */
                isFocusable(): any;
                /**
                 * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                 * 
                 */
                isLeftToRight(): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: String, func: Function): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: Function, func: Function): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: number): any;
                /**
                 * 
                 */
                postCreate(): void;
                /**
                 * 
                 */
                postMixInProperties(): void;
                /**
                 * Set a property on a widget
                 * Sets named properties on a widget which may potentially be handled by a
                 * setter in the widget.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _setFooAttr(), calling
                 * myWidget.set("foo", "Howdy!") would be equivalent to calling
                 * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                 * would be equivalent to the statement widget.bar = 3;
                 * 
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * myWidget.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * });
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: any, value: any): any;
                /**
                 * Deprecated.  Use set() instead.
                 * 
                 * @param attr             
                 * @param value             
                 */
                setAttribute(attr: String, value: any): void;
                /**
                 * Processing after the DOM fragment is added to the document
                 * Called after a widget and its children have been created and added to the page,
                 * and all related widgets have finished their create() cycle, up through postCreate().
                 * 
                 * Note that startup() may be called while the widget is still hidden, for example if the widget is
                 * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
                 * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
                 * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
                 * 
                 */
                startup(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                 * 
                 * Subscribes to the specified topic and calls the specified method
                 * of this object and registers for unsubscribe() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.subscribe, except with the
                 * implicit use of this widget as the target object.
                 * 
                 * @param t The topic             
                 * @param method The callback             
                 */
                subscribe(t: String, method: Function): any;
                /**
                 * Returns a string that represents the widget.
                 * When a widget is cast to a string, this method will be used to generate the
                 * output. Currently, it does not implement any sort of reversible
                 * serialization.
                 * 
                 */
                toString(): string;
                /**
                 * Deprecated. Override destroy() instead to implement custom widget tear-down
                 * behavior.
                 * 
                 */
                uninitialize(): boolean;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Unsubscribes handle created by this.subscribe.
                 * Also removes handle from this widget's list of subscriptions
                 * 
                 * @param handle             
                 */
                unsubscribe(handle: Object): void;
                /**
                 * Watches a property for changes
                 * 
                 * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                 * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                 */
                watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                /**
                 * Static method to get a template based on the templatePath or
                 * templateString key
                 */
                getCachedTemplate(): any;
                /**
                 * Called when the widget stops being "active" because
                 * focus moved to something outside of it, or the user
                 * clicked somewhere outside of it, or the widget was
                 * hidden.
                 * 
                 */
                onBlur(): void;
                /**
                 * Connect to this function to receive notifications of mouse click events.
                 * 
                 * @param event mouse Event             
                 */
                onClick(event: any): void;
                /**
                 * Called when this widget is being displayed as a popup (ex: a Calendar popped
                 * up from a DateTextBox), and it is hidden.
                 * This is called from the dijit.popup code, and should not be called directly.
                 * 
                 * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                 * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                 * 
                 */
                onClose(): boolean;
                /**
                 * Connect to this function to receive notifications of mouse double click events.
                 * 
                 * @param event mouse Event             
                 */
                onDblClick(event: any): void;
                /**
                 * Called when the widget becomes "active" because
                 * it or a widget inside of it either has focus, or has recently
                 * been clicked.
                 * 
                 */
                onFocus(): void;
                /**
                 * Called when another widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onHide(): void;
                /**
                 * Connect to this function to receive notifications of keys being pressed down.
                 * 
                 * @param event key Event             
                 */
                onKeyDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of printable keys being typed.
                 * 
                 * @param event key Event             
                 */
                onKeyPress(event: any): void;
                /**
                 * Connect to this function to receive notifications of keys being released.
                 * 
                 * @param event key Event             
                 */
                onKeyUp(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is pressed down.
                 * 
                 * @param event mouse Event             
                 */
                onMouseDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseEnter(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseLeave(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseMove(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOut(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOver(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is released.
                 * 
                 * @param event mouse Event             
                 */
                onMouseUp(event: any): void;
                /**
                 * Called when this widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onShow(): void;
            }
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/BorderContainer.ChildWidgetProperties.html
             *
             * These properties can be specified for the children of a BorderContainer.
             * 
             */
            interface ChildWidgetProperties {
                /**
                 * Synonym for region, except using "client" instead of "center".  Deprecated; use region instead.
                 * 
                 */
                layoutAlign: string;
                /**
                 * Children with a higher layoutPriority will be placed closer to the LayoutContainer center,
                 * between children with a lower layoutPriority.
                 * 
                 */
                layoutPriority: number;
                /**
                 * Specifies a maximum size (in pixels) for this widget when resized by a splitter.
                 * 
                 */
                maxSize: number;
                /**
                 * Specifies a minimum size (in pixels) for this widget when resized by a splitter.
                 * 
                 */
                minSize: number;
                /**
                 * Values: "top", "bottom", "leading", "trailing", "left", "right", "center".
                 * See the dijit/layout/LayoutContainer description for details.
                 * 
                 */
                region: string;
                /**
                 * Parameter for children where region != "center".
                 * If true, enables user to resize the widget by putting a draggable splitter between
                 * this widget and the region=center widget.
                 * 
                 */
                splitter: boolean;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/AccordionPane.html
         *
         * Deprecated widget.   Use dijit/layout/ContentPane instead.
         * 
         */
        class AccordionPane extends dijit.layout.ContentPane {
            constructor();
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The innerHTML of the ContentPane.
             * Note that the initialization parameter / argument to set("content", ...)
             * can be a String, DomNode, Nodelist, or _Widget.
             * 
             */
            "content": string;
            set(property:"content", value: string): void;
            get(property:"content"): string;
            watch(property:"content", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * 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;
            set(property:"doLayout", value: boolean): void;
            get(property:"doLayout"): boolean;
            watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Message that shows if an error occurs
             * 
             */
            "errorMessage": string;
            set(property:"errorMessage", value: string): void;
            get(property:"errorMessage"): string;
            watch(property:"errorMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Extract visible content from inside of <body> .... </body>.
             * I.e., strip <html> and <head> (and it's contents) from the href
             * 
             */
            "extractContent": boolean;
            set(property:"extractContent", value: boolean): void;
            get(property:"extractContent"): boolean;
            watch(property:"extractContent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The href of the content that displays now.
             * Set this at construction if you want to load data externally when the
             * pane is shown.  (Set preload=true to load it immediately.)
             * Changing href after creation doesn't have any effect; Use set('href', ...);
             * 
             */
            "href": string;
            set(property:"href", value: string): void;
            get(property:"href"): string;
            watch(property:"href", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Parameters to pass to xhrGet() request, for example:
             * 
             * <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
             * 
             */
            "ioArgs": Object;
            set(property:"ioArgs", value: Object): void;
            get(property:"ioArgs"): Object;
            watch(property:"ioArgs", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Indicates that this widget will call resize() on it's child widgets
             * when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if the ContentPane has data in it, either specified
             * during initialization (via href or inline content), or set
             * via set('content', ...) / set('href', ...)
             * 
             * False if it doesn't have any content, or if ContentPane is
             * still in the process of downloading href.
             * 
             */
            "isLoaded": boolean;
            set(property:"isLoaded", value: boolean): void;
            get(property:"isLoaded"): boolean;
            watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Message that shows while downloading
             * 
             */
            "loadingMessage": string;
            set(property:"loadingMessage", value: string): void;
            get(property:"loadingMessage"): string;
            watch(property:"loadingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is the dojo.Deferred returned by set('href', ...) and refresh().
             * Calling onLoadDeferred.then() registers your
             * callback to be called only once, when the prior set('href', ...) call or
             * the initial href parameter to the constructor finishes loading.
             * 
             * This is different than an onLoad() handler which gets called any time any href
             * or content is loaded.
             * 
             */
            "onLoadDeferred": Object;
            set(property:"onLoadDeferred", value: Object): void;
            get(property:"onLoadDeferred"): Object;
            watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Parse content and create the widgets, if any.
             * 
             */
            "parseOnLoad": boolean;
            set(property:"parseOnLoad", value: boolean): void;
            get(property:"parseOnLoad"): boolean;
            watch(property:"parseOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 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 compatibility
             * reasons defaults to dojo._scopeName (which is "dojo" except when
             * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
             * 
             */
            "parserScope": string;
            set(property:"parserScope", value: string): void;
            get(property:"parserScope"): string;
            watch(property:"parserScope", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Force load of data on initialization even if pane is hidden.
             * 
             */
            "preload": boolean;
            set(property:"preload", value: boolean): void;
            get(property:"preload"): boolean;
            watch(property:"preload", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Prevent caching of data from href's by appending a timestamp to the href.
             * 
             */
            "preventCache": boolean;
            set(property:"preventCache", value: boolean): void;
            get(property:"preventCache"): boolean;
            watch(property:"preventCache", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Refresh (re-download) content when pane goes from hidden to shown
             * 
             */
            "refreshOnShow": boolean;
            set(property:"refreshOnShow", value: boolean): void;
            get(property:"refreshOnShow"): boolean;
            watch(property:"refreshOnShow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "stopParser": boolean;
            set(property:"stopParser", value: boolean): void;
            get(property:"stopParser"): boolean;
            watch(property:"stopParser", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Cancels an in-flight download of content
             * 
             */
            cancel(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * 
             * @param params             
             * @param srcNodeRef             
             */
            create(params: any, srcNodeRef: any): void;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Destroy all the widgets inside the ContentPane and empty containerNode
             * 
             * @param preserveDom             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy the ContentPane and its contents
             * 
             * @param preserveDom             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Function that should grab the content specified via href.
             * 
             * @param args An object with the following properties:handleAs (String, optional): Acceptable values are: text (default), json, json-comment-optional,json-comment-filtered, javascript, xml. See dojo/_base/xhr.contentHandlerssync (Boolean, optional): false is default. Indicates whether the request shouldbe a synchronous (blocking) request.headers (Object, optional): Additional HTTP headers to send in the request.failOk (Boolean, optional): false is default. Indicates whether a request should beallowed to fail (and therefore no console error message inthe event of a failure)contentType (String|Boolean): "application/x-www-form-urlencoded" is default. Set to false toprevent a Content-Type header from being sent, or to a stringto send a different Content-Type.load: This function will becalled on a successful HTTP response code.error: This function willbe called when the request fails due to a network or server error, the urlis invalid, etc. It will also be called if the load or handle callback throws anexception, unless djConfig.debugAtAllCosts is true.  This allows deployed applicationsto continue to run even when a logic error happens in the callback, while makingit easier to troubleshoot while in debug mode.handle: This function willbe called at the end of every request, whether or not an error occurs.url (String): URL to server endpoint.content (Object, optional): Contains properties with string values. Theseproperties will be serialized as name1=value2 andpassed in the request.timeout (Integer, optional): Milliseconds to wait for the response. If this timepasses, the then error callbacks are called.form (DOMNode, optional): DOM node for a form. Used to extract the form valuesand send to the server.preventCache (Boolean, optional): Default is false. If true, then a"dojo.preventCache" parameter is sent in the requestwith a value that changes with each request(timestamp). Useful only with GET-type requests.rawBody (String, optional): Sets the raw body for an HTTP request. If this is used, then the contentproperty is ignored. This is mostly useful for HTTP methods that havea body to their requests, like PUT or POST. This property can be used insteadof postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.ioPublish (Boolean, optional): Set this explicitly to false to prevent publishing of topics related toIO operations. Otherwise, if djConfig.ioPublish is set to true, topicswill be published via dojo/topic.publish() for different phases of an IO operation.See dojo/main.__IoPublish for a list of topics that are published.            
             */
            ioMethod(args: Object): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param params             
             * @param node             
             * @param ctor             
             */
            markupFactory(params: any, node: any, ctor: any): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * [Re]download contents of href and display
             * cancels any currently in-flight requests
             * posts "loading..." message
             * sends XHR to download new data
             * 
             */
            refresh(): any;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * See dijit/layout/_LayoutWidget.resize() for description.
             * Although ContentPane doesn't extend _LayoutWidget, it does implement
             * the same API.
             * 
             * @param changeSize             
             * @param resultSize             
             */
            resize(changeSize: any, resultSize: any): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.   Use set('content', ...) instead.
             * 
             * @param data             
             */
            setContent(data: String): void;
            /**
             * Deprecated.   Use set('content', ...) instead.
             * 
             * @param data             
             */
            setContent(data: HTMLElement): void;
            /**
             * Deprecated.   Use set('content', ...) instead.
             * 
             * @param data             
             */
            setContent(data: NodeList): void;
            /**
             * Deprecated.   Use set('href', ...) instead.
             * 
             * @param href             
             */
            setHref(href: String): any;
            /**
             * Deprecated.   Use set('href', ...) instead.
             * 
             * @param href             
             */
            setHref(href: URL): any;
            /**
             * Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * 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.
             * 
             * @param error             
             */
            onContentError(error: Error): void;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when download is finished.
             * 
             */
            onDownloadEnd(): 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.
             * 
             * @param error             
             */
            onDownloadError(error: Error): any;
            /**
             * Called before download starts.
             * The string returned by this function will be the html
             * that tells the user we are loading something.
             * Override with your own function if you want to change text.
             * 
             */
            onDownloadStart(): any;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Event hook, is called after everything is loaded and widgetified
             * 
             * @param data             
             */
            onLoad(data: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * called when this pane is selected
             * 
             */
            onSelected(): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
            /**
             * Event hook, is called before old content is cleared
             * 
             */
            onUnload(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/LayoutContainer.html
         *
         * A LayoutContainer is a box with a specified size, such as style="width: 500px; height: 500px;",
         * that contains a child widget marked region="center" and optionally children widgets marked
         * region equal to "top", "bottom", "leading", "trailing", "left" or "right".
         * Children along the edges will be laid out according to width or height dimensions. The remaining
         * space is designated for the center region.
         * 
         * The outer size must be specified on the LayoutContainer node.  Width must be specified for the sides
         * and height for the top and bottom, respectively.  No dimensions should be specified on the center;
         * it will fill the remaining space.  Regions named "leading" and "trailing" may be used just like
         * "left" and "right" except that they will be reversed in right-to-left environments.
         * 
         * For complex layouts, multiple children can be specified for a single region.   In this case, the
         * layoutPriority flag on the children determines which child is closer to the edge (low layoutPriority)
         * and which child is closer to the center (high layoutPriority).   layoutPriority can also be used
         * instead of the design attribute to control layout precedence of horizontal vs. vertical panes.
         * 
         * See LayoutContainer.ChildWidgetProperties for details on the properties that can be set on
         * children of a LayoutContainer.
         * 
         * If layoutPriority is not set, lays out each child in the natural order the children occur in.
         * Basically each child is laid out into the "remaining space", where "remaining space" is initially
         * the content area of this widget, but is reduced to a smaller rectangle each time a child is added.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class LayoutContainer extends dijit.layout._LayoutWidget {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * These properties can be specified for the children of a LayoutContainer.
             * 
             */
            "ChildWidgetProperties": Object;
            set(property:"ChildWidgetProperties", value: Object): void;
            get(property:"ChildWidgetProperties"): Object;
            watch(property:"ChildWidgetProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 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.
             * 
             */
            "design": string;
            set(property:"design", value: string): void;
            get(property:"design"): string;
            watch(property:"design", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Indicates that this widget is going to call resize() on its
             * children widgets, setting their size, when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * @param child             
             * @param insertIndex               Optional            
             */
            addChild(child: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the index of this widget within its container parent.
             * It returns -1 if the parent does not exist, or if the parent
             * is not a dijit/_Container
             * 
             */
            getIndexInParent(): any;
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns null if this is the last child of the parent,
             * otherwise returns the next element sibling to the "right".
             * 
             */
            getNextSibling(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns null if this is the first child of the parent,
             * otherwise returns the next element sibling to the "left".
             * 
             */
            getPreviousSibling(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            layout(): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * 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:
             * 
             * Sets this._borderBox and this._contentBox to the new size of
             *  the widget.  Queries the current domNode size if necessary.
             * Calls layout() to resize contents (and maybe adjust child widgets).
             * 
             * @param changeSize               OptionalSets the widget to this margin-box size and position.May include any/all of the following properties:{w: int, h: int, l: int, t: int}             
             * @param resultSize               OptionalThe margin-box size of this widget after applying changeSize (ifchangeSize is specified).  If caller knows this size andpasses it in, we don't need to query the browser to get the size.{w: int, h: int}             
             */
            resize(changeSize: Object, resultSize: Object): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module LayoutContainer {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/LayoutContainer.ChildWidgetProperties.html
             *
             * These properties can be specified for the children of a LayoutContainer.
             * 
             */
            interface ChildWidgetProperties {
                /**
                 * Synonym for region, except using "client" instead of "center".  Deprecated; use region instead.
                 * 
                 */
                layoutAlign: string;
                /**
                 * Children with a higher layoutPriority will be placed closer to the LayoutContainer center,
                 * between children with a lower layoutPriority.
                 * 
                 */
                layoutPriority: number;
                /**
                 * Values: "top", "bottom", "leading", "trailing", "left", "right", "center".
                 * See the dijit/layout/LayoutContainer description for details.
                 * 
                 */
                region: string;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/ContentPane.html
         *
         * A widget containing an HTML fragment, specified inline
         * or by uri.  Fragment may include widgets.
         * This widget embeds a document fragment in the page, specified
         * either by uri, javascript generated markup or DOM reference.
         * Any widgets within this content are instantiated and managed,
         * but laid out according to the HTML structure.  Unlike IFRAME,
         * ContentPane embeds a document fragment as would be found
         * inside the BODY tag of a full HTML document.  It should not
         * contain the HTML, HEAD, or BODY tags.
         * For more advanced functionality with scripts and
         * stylesheets, see dojox/layout/ContentPane.  This widget may be
         * used stand alone or as a base class for other widgets.
         * ContentPane is useful as a child of other layout containers
         * such as BorderContainer or TabContainer, but note that those
         * widgets can contain any widget as a child.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class ContentPane extends dijit._Widget implements dijit._Container, dijit.layout._ContentPaneResizeMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The innerHTML of the ContentPane.
             * Note that the initialization parameter / argument to set("content", ...)
             * can be a String, DomNode, Nodelist, or _Widget.
             * 
             */
            "content": string;
            set(property:"content", value: string): void;
            get(property:"content"): string;
            watch(property:"content", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * 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;
            set(property:"doLayout", value: boolean): void;
            get(property:"doLayout"): boolean;
            watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Message that shows if an error occurs
             * 
             */
            "errorMessage": string;
            set(property:"errorMessage", value: string): void;
            get(property:"errorMessage"): string;
            watch(property:"errorMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Extract visible content from inside of <body> .... </body>.
             * I.e., strip <html> and <head> (and it's contents) from the href
             * 
             */
            "extractContent": boolean;
            set(property:"extractContent", value: boolean): void;
            get(property:"extractContent"): boolean;
            watch(property:"extractContent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The href of the content that displays now.
             * Set this at construction if you want to load data externally when the
             * pane is shown.  (Set preload=true to load it immediately.)
             * Changing href after creation doesn't have any effect; Use set('href', ...);
             * 
             */
            "href": string;
            set(property:"href", value: string): void;
            get(property:"href"): string;
            watch(property:"href", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Parameters to pass to xhrGet() request, for example:
             * 
             * <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
             * 
             */
            "ioArgs": Object;
            set(property:"ioArgs", value: Object): void;
            get(property:"ioArgs"): Object;
            watch(property:"ioArgs", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Indicates that this widget will call resize() on it's child widgets
             * when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if the ContentPane has data in it, either specified
             * during initialization (via href or inline content), or set
             * via set('content', ...) / set('href', ...)
             * 
             * False if it doesn't have any content, or if ContentPane is
             * still in the process of downloading href.
             * 
             */
            "isLoaded": boolean;
            set(property:"isLoaded", value: boolean): void;
            get(property:"isLoaded"): boolean;
            watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Message that shows while downloading
             * 
             */
            "loadingMessage": string;
            set(property:"loadingMessage", value: string): void;
            get(property:"loadingMessage"): string;
            watch(property:"loadingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is the dojo.Deferred returned by set('href', ...) and refresh().
             * Calling onLoadDeferred.then() registers your
             * callback to be called only once, when the prior set('href', ...) call or
             * the initial href parameter to the constructor finishes loading.
             * 
             * This is different than an onLoad() handler which gets called any time any href
             * or content is loaded.
             * 
             */
            "onLoadDeferred": Object;
            set(property:"onLoadDeferred", value: Object): void;
            get(property:"onLoadDeferred"): Object;
            watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Parse content and create the widgets, if any.
             * 
             */
            "parseOnLoad": boolean;
            set(property:"parseOnLoad", value: boolean): void;
            get(property:"parseOnLoad"): boolean;
            watch(property:"parseOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 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 compatibility
             * reasons defaults to dojo._scopeName (which is "dojo" except when
             * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
             * 
             */
            "parserScope": string;
            set(property:"parserScope", value: string): void;
            get(property:"parserScope"): string;
            watch(property:"parserScope", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Force load of data on initialization even if pane is hidden.
             * 
             */
            "preload": boolean;
            set(property:"preload", value: boolean): void;
            get(property:"preload"): boolean;
            watch(property:"preload", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Prevent caching of data from href's by appending a timestamp to the href.
             * 
             */
            "preventCache": boolean;
            set(property:"preventCache", value: boolean): void;
            get(property:"preventCache"): boolean;
            watch(property:"preventCache", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Refresh (re-download) content when pane goes from hidden to shown
             * 
             */
            "refreshOnShow": boolean;
            set(property:"refreshOnShow", value: boolean): void;
            get(property:"refreshOnShow"): boolean;
            watch(property:"refreshOnShow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "stopParser": boolean;
            set(property:"stopParser", value: boolean): void;
            get(property:"stopParser"): boolean;
            watch(property:"stopParser", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Cancels an in-flight download of content
             * 
             */
            cancel(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * 
             * @param params             
             * @param srcNodeRef             
             */
            create(params: any, srcNodeRef: any): void;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Destroy all the widgets inside the ContentPane and empty containerNode
             * 
             * @param preserveDom             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy the ContentPane and its contents
             * 
             * @param preserveDom             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Function that should grab the content specified via href.
             * 
             * @param args An object with the following properties:handleAs (String, optional): Acceptable values are: text (default), json, json-comment-optional,json-comment-filtered, javascript, xml. See dojo/_base/xhr.contentHandlerssync (Boolean, optional): false is default. Indicates whether the request shouldbe a synchronous (blocking) request.headers (Object, optional): Additional HTTP headers to send in the request.failOk (Boolean, optional): false is default. Indicates whether a request should beallowed to fail (and therefore no console error message inthe event of a failure)contentType (String|Boolean): "application/x-www-form-urlencoded" is default. Set to false toprevent a Content-Type header from being sent, or to a stringto send a different Content-Type.load: This function will becalled on a successful HTTP response code.error: This function willbe called when the request fails due to a network or server error, the urlis invalid, etc. It will also be called if the load or handle callback throws anexception, unless djConfig.debugAtAllCosts is true.  This allows deployed applicationsto continue to run even when a logic error happens in the callback, while makingit easier to troubleshoot while in debug mode.handle: This function willbe called at the end of every request, whether or not an error occurs.url (String): URL to server endpoint.content (Object, optional): Contains properties with string values. Theseproperties will be serialized as name1=value2 andpassed in the request.timeout (Integer, optional): Milliseconds to wait for the response. If this timepasses, the then error callbacks are called.form (DOMNode, optional): DOM node for a form. Used to extract the form valuesand send to the server.preventCache (Boolean, optional): Default is false. If true, then a"dojo.preventCache" parameter is sent in the requestwith a value that changes with each request(timestamp). Useful only with GET-type requests.rawBody (String, optional): Sets the raw body for an HTTP request. If this is used, then the contentproperty is ignored. This is mostly useful for HTTP methods that havea body to their requests, like PUT or POST. This property can be used insteadof postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.ioPublish (Boolean, optional): Set this explicitly to false to prevent publishing of topics related toIO operations. Otherwise, if djConfig.ioPublish is set to true, topicswill be published via dojo/topic.publish() for different phases of an IO operation.See dojo/main.__IoPublish for a list of topics that are published.            
             */
            ioMethod(args: Object): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param params             
             * @param node             
             * @param ctor             
             */
            markupFactory(params: any, node: any, ctor: any): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * [Re]download contents of href and display
             * cancels any currently in-flight requests
             * posts "loading..." message
             * sends XHR to download new data
             * 
             */
            refresh(): any;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * See dijit/layout/_LayoutWidget.resize() for description.
             * Although ContentPane doesn't extend _LayoutWidget, it does implement
             * the same API.
             * 
             * @param changeSize             
             * @param resultSize             
             */
            resize(changeSize: any, resultSize: any): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.   Use set('content', ...) instead.
             * 
             * @param data             
             */
            setContent(data: String): void;
            /**
             * Deprecated.   Use set('content', ...) instead.
             * 
             * @param data             
             */
            setContent(data: HTMLElement): void;
            /**
             * Deprecated.   Use set('content', ...) instead.
             * 
             * @param data             
             */
            setContent(data: NodeList): void;
            /**
             * Deprecated.   Use set('href', ...) instead.
             * 
             * @param href             
             */
            setHref(href: String): any;
            /**
             * Deprecated.   Use set('href', ...) instead.
             * 
             * @param href             
             */
            setHref(href: URL): any;
            /**
             * Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * 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.
             * 
             * @param error             
             */
            onContentError(error: Error): void;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when download is finished.
             * 
             */
            onDownloadEnd(): 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.
             * 
             * @param error             
             */
            onDownloadError(error: Error): any;
            /**
             * Called before download starts.
             * The string returned by this function will be the html
             * that tells the user we are loading something.
             * Override with your own function if you want to change text.
             * 
             */
            onDownloadStart(): any;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Event hook, is called after everything is loaded and widgetified
             * 
             * @param data             
             */
            onLoad(data: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
            /**
             * Event hook, is called before old content is cleared
             * 
             */
            onUnload(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/LinkPane.html
         *
         * A ContentPane with an href where (when declared in markup)
         * the title is specified as innerHTML rather than as a title attribute.
         * LinkPane is just a ContentPane that is declared in markup similarly
         * to an anchor.  The anchor's body (the words between <a> and </a>)
         * become the title of the widget (used for TabContainer, AccordionContainer, etc.)
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class LinkPane extends dijit.layout.ContentPane implements dijit._TemplatedMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * The innerHTML of the ContentPane.
             * Note that the initialization parameter / argument to set("content", ...)
             * can be a String, DomNode, Nodelist, or _Widget.
             * 
             */
            "content": string;
            set(property:"content", value: string): void;
            get(property:"content"): string;
            watch(property:"content", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * 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;
            set(property:"doLayout", value: boolean): void;
            get(property:"doLayout"): boolean;
            watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Message that shows if an error occurs
             * 
             */
            "errorMessage": string;
            set(property:"errorMessage", value: string): void;
            get(property:"errorMessage"): string;
            watch(property:"errorMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Extract visible content from inside of <body> .... </body>.
             * I.e., strip <html> and <head> (and it's contents) from the href
             * 
             */
            "extractContent": boolean;
            set(property:"extractContent", value: boolean): void;
            get(property:"extractContent"): boolean;
            watch(property:"extractContent", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The href of the content that displays now.
             * Set this at construction if you want to load data externally when the
             * pane is shown.  (Set preload=true to load it immediately.)
             * Changing href after creation doesn't have any effect; Use set('href', ...);
             * 
             */
            "href": string;
            set(property:"href", value: string): void;
            get(property:"href"): string;
            watch(property:"href", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Parameters to pass to xhrGet() request, for example:
             * 
             * <div data-dojo-type="dijit/layout/ContentPane" data-dojo-props="href: './bar', ioArgs: {timeout: 500}">
             * 
             */
            "ioArgs": Object;
            set(property:"ioArgs", value: Object): void;
            get(property:"ioArgs"): Object;
            watch(property:"ioArgs", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Indicates that this widget will call resize() on it's child widgets
             * when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if the ContentPane has data in it, either specified
             * during initialization (via href or inline content), or set
             * via set('content', ...) / set('href', ...)
             * 
             * False if it doesn't have any content, or if ContentPane is
             * still in the process of downloading href.
             * 
             */
            "isLoaded": boolean;
            set(property:"isLoaded", value: boolean): void;
            get(property:"isLoaded"): boolean;
            watch(property:"isLoaded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Message that shows while downloading
             * 
             */
            "loadingMessage": string;
            set(property:"loadingMessage", value: string): void;
            get(property:"loadingMessage"): string;
            watch(property:"loadingMessage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is the dojo.Deferred returned by set('href', ...) and refresh().
             * Calling onLoadDeferred.then() registers your
             * callback to be called only once, when the prior set('href', ...) call or
             * the initial href parameter to the constructor finishes loading.
             * 
             * This is different than an onLoad() handler which gets called any time any href
             * or content is loaded.
             * 
             */
            "onLoadDeferred": Object;
            set(property:"onLoadDeferred", value: Object): void;
            get(property:"onLoadDeferred"): Object;
            watch(property:"onLoadDeferred", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Parse content and create the widgets, if any.
             * 
             */
            "parseOnLoad": boolean;
            set(property:"parseOnLoad", value: boolean): void;
            get(property:"parseOnLoad"): boolean;
            watch(property:"parseOnLoad", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 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 compatibility
             * reasons defaults to dojo._scopeName (which is "dojo" except when
             * multi-version support is used, when it will be something like dojo16, dojo20, etc.)
             * 
             */
            "parserScope": string;
            set(property:"parserScope", value: string): void;
            get(property:"parserScope"): string;
            watch(property:"parserScope", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Force load of data on initialization even if pane is hidden.
             * 
             */
            "preload": boolean;
            set(property:"preload", value: boolean): void;
            get(property:"preload"): boolean;
            watch(property:"preload", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Prevent caching of data from href's by appending a timestamp to the href.
             * 
             */
            "preventCache": boolean;
            set(property:"preventCache", value: boolean): void;
            get(property:"preventCache"): boolean;
            watch(property:"preventCache", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Refresh (re-download) content when pane goes from hidden to shown
             * 
             */
            "refreshOnShow": boolean;
            set(property:"refreshOnShow", value: boolean): void;
            get(property:"refreshOnShow"): boolean;
            watch(property:"refreshOnShow", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "stopParser": boolean;
            set(property:"stopParser", value: boolean): void;
            get(property:"stopParser"): boolean;
            watch(property:"stopParser", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Cancels an in-flight download of content
             * 
             */
            cancel(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * 
             * @param params             
             * @param srcNodeRef             
             */
            create(params: any, srcNodeRef: any): void;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Destroy all the widgets inside the ContentPane and empty containerNode
             * 
             * @param preserveDom             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy the ContentPane and its contents
             * 
             * @param preserveDom             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Function that should grab the content specified via href.
             * 
             * @param args An object with the following properties:handleAs (String, optional): Acceptable values are: text (default), json, json-comment-optional,json-comment-filtered, javascript, xml. See dojo/_base/xhr.contentHandlerssync (Boolean, optional): false is default. Indicates whether the request shouldbe a synchronous (blocking) request.headers (Object, optional): Additional HTTP headers to send in the request.failOk (Boolean, optional): false is default. Indicates whether a request should beallowed to fail (and therefore no console error message inthe event of a failure)contentType (String|Boolean): "application/x-www-form-urlencoded" is default. Set to false toprevent a Content-Type header from being sent, or to a stringto send a different Content-Type.load: This function will becalled on a successful HTTP response code.error: This function willbe called when the request fails due to a network or server error, the urlis invalid, etc. It will also be called if the load or handle callback throws anexception, unless djConfig.debugAtAllCosts is true.  This allows deployed applicationsto continue to run even when a logic error happens in the callback, while makingit easier to troubleshoot while in debug mode.handle: This function willbe called at the end of every request, whether or not an error occurs.url (String): URL to server endpoint.content (Object, optional): Contains properties with string values. Theseproperties will be serialized as name1=value2 andpassed in the request.timeout (Integer, optional): Milliseconds to wait for the response. If this timepasses, the then error callbacks are called.form (DOMNode, optional): DOM node for a form. Used to extract the form valuesand send to the server.preventCache (Boolean, optional): Default is false. If true, then a"dojo.preventCache" parameter is sent in the requestwith a value that changes with each request(timestamp). Useful only with GET-type requests.rawBody (String, optional): Sets the raw body for an HTTP request. If this is used, then the contentproperty is ignored. This is mostly useful for HTTP methods that havea body to their requests, like PUT or POST. This property can be used insteadof postData and putData for dojo/_base/xhr.rawXhrPost and dojo/_base/xhr.rawXhrPut respectively.ioPublish (Boolean, optional): Set this explicitly to false to prevent publishing of topics related toIO operations. Otherwise, if djConfig.ioPublish is set to true, topicswill be published via dojo/topic.publish() for different phases of an IO operation.See dojo/main.__IoPublish for a list of topics that are published.            
             */
            ioMethod(args: Object): any;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param params             
             * @param node             
             * @param ctor             
             */
            markupFactory(params: any, node: any, ctor: any): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * [Re]download contents of href and display
             * cancels any currently in-flight requests
             * posts "loading..." message
             * sends XHR to download new data
             * 
             */
            refresh(): any;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * See dijit/layout/_LayoutWidget.resize() for description.
             * Although ContentPane doesn't extend _LayoutWidget, it does implement
             * the same API.
             * 
             * @param changeSize             
             * @param resultSize             
             */
            resize(changeSize: any, resultSize: any): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.   Use set('content', ...) instead.
             * 
             * @param data             
             */
            setContent(data: String): void;
            /**
             * Deprecated.   Use set('content', ...) instead.
             * 
             * @param data             
             */
            setContent(data: HTMLElement): void;
            /**
             * Deprecated.   Use set('content', ...) instead.
             * 
             * @param data             
             */
            setContent(data: NodeList): void;
            /**
             * Deprecated.   Use set('href', ...) instead.
             * 
             * @param href             
             */
            setHref(href: String): any;
            /**
             * Deprecated.   Use set('href', ...) instead.
             * 
             * @param href             
             */
            setHref(href: URL): any;
            /**
             * Call startup() on all children including non _Widget ones like dojo/dnd/Source objects
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * 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.
             * 
             * @param error             
             */
            onContentError(error: Error): void;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when download is finished.
             * 
             */
            onDownloadEnd(): 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.
             * 
             * @param error             
             */
            onDownloadError(error: Error): any;
            /**
             * Called before download starts.
             * The string returned by this function will be the html
             * that tells the user we are loading something.
             * Override with your own function if you want to change text.
             * 
             */
            onDownloadStart(): any;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Event hook, is called after everything is loaded and widgetified
             * 
             * @param data             
             */
            onLoad(data: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
            /**
             * Event hook, is called before old content is cleared
             * 
             */
            onUnload(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/ScrollingTabController.html
         *
         * Set of tabs with left/right arrow keys and a menu to switch between tabs not
         * all fitting on a single row.
         * Works only for horizontal tabs (either above or below the content, not to the left
         * or right).
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class ScrollingTabController extends dijit.layout.TabController implements dijit._WidgetsInTemplateMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Class of [x] close icon, used by event delegation code to tell when close button was clicked
             * 
             */
            "buttonWidgetCloseClass": string;
            set(property:"buttonWidgetCloseClass", value: string): void;
            get(property:"buttonWidgetCloseClass"): string;
            watch(property:"buttonWidgetCloseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The id of the page container that I point to
             * 
             */
            "containerId": string;
            set(property:"containerId", value: string): void;
            get(property:"containerId"): string;
            watch(property:"containerId", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Used to provide a context require to the dojo/parser in order to be
             * able to use relative MIDs (e.g. ./Widget) in the widget's template.
             * 
             */
            "contextRequire": Function;
            set(property:"contextRequire", value: Function): void;
            get(property:"contextRequire"): Function;
            watch(property:"contextRequire", callback:{(property?:string, oldValue?:Function, newValue?: Function):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines where tabs go relative to the content.
             * "top", "bottom", "left-h", "right-h"
             * 
             */
            "tabPosition": string;
            set(property:"tabPosition", value: string): void;
            get(property:"tabPosition"): string;
            watch(property:"tabPosition", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The css class to apply to the tab strip, if it is visible.
             * 
             */
            "tabStripClass": string;
            set(property:"tabStripClass", value: string): void;
            get(property:"tabStripClass"): string;
            watch(property:"tabStripClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * True if a menu should be used to select tabs when they are too
             * wide to fit the TabContainer, false otherwise.
             * 
             */
            "useMenu": boolean;
            set(property:"useMenu", value: boolean): void;
            get(property:"useMenu"): boolean;
            watch(property:"useMenu", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if a slider should be used to select tabs when they are too
             * wide to fit the TabContainer, false otherwise.
             * 
             */
            "useSlider": boolean;
            set(property:"useSlider", value: boolean): void;
            get(property:"useSlider"): boolean;
            watch(property:"useSlider", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Should we parse the template to find widgets that might be
             * declared in markup inside it?  (Remove for 2.0 and assume true)
             * 
             */
            "widgetsInTemplate": boolean;
            set(property:"widgetsInTemplate", value: boolean): void;
            get(property:"widgetsInTemplate"): boolean;
            watch(property:"widgetsInTemplate", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * The tab widget to create to correspond to each page
             * 
             */
            buttonWidget(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Creates a dojo._Animation object that smoothly scrolls the tab list
             * either to a fixed horizontal pixel value, or to the selected tab.
             * If an number argument is passed to the function, that horizontal
             * pixel position is scrolled to.  Otherwise the currently selected
             * tab is scrolled to.
             * 
             * @param x               OptionalAn optional pixel value to scroll to, indicating distance from left.             
             */
            createSmoothScroll(x: number): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             * @param preserveDom             
             */
            destroy(preserveDom?: any): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Scrolls the tab list to the left or right by 75% of the widget width.
             * 
             * @param direction If the direction is 1, the widget scrolls to the right, if it is -1,it scrolls to the left.             
             * @param node             
             */
            doSlide(direction: number, node: HTMLElement): void;
            /**
             * Scrolls the menu to the left.
             * 
             * @param e The mouse click event.             
             */
            doSlideLeft(e: Event): void;
            /**
             * Scrolls the menu to the right.
             * 
             * @param e The mouse click event.             
             */
            doSlideRight(e: Event): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Returns the button corresponding to the pane w/the given id.
             * 
             * @param id             
             */
            pane2button(id: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * Hides or displays the buttons used to scroll the tab list and launch the menu
             * that selects tabs.
             * 
             * @param dim             
             */
            resize(dim: any): Object;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * 
             * @param page             
             * @param insertIndex             
             */
            onAddChild(page: any, insertIndex: any): void;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * 
             * @param page             
             * @param insertIndex             
             */
            onRemoveChild(page: any, insertIndex: any): void;
            /**
             * Smoothly scrolls to a tab when it is selected.
             * 
             * @param page             
             */
            onSelectChild(page: dijit._WidgetBase): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
            /**
             * 
             */
            onStartup(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/SplitContainer.html
         *
         * Deprecated.  Use dijit/layout/BorderContainer instead.
         * A Container widget with sizing handles in-between each child.
         * Contains multiple children widgets, all of which are displayed side by side
         * (either horizontally or vertically); there's a bar between each of the children,
         * and you can adjust the relative size of each child by dragging the bars.
         * 
         * You must specify a size (width and height) for the SplitContainer.
         * 
         * See SplitContainer.ChildWidgetProperties for details on the properties that can be set on
         * children of a SplitContainer.
         * 
         */
        class SplitContainer extends dijit.layout._LayoutWidget {
            constructor();
            /**
             * If true, the children's size changes as you drag the bar;
             * otherwise, the sizes don't change until you drop the bar (by mouse-up)
             * 
             */
            "activeSizing": boolean;
            set(property:"activeSizing", value: boolean): void;
            get(property:"activeSizing"): boolean;
            watch(property:"activeSizing", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * These properties can be specified for the children of a SplitContainer.
             * 
             */
            "ChildWidgetProperties": Object;
            set(property:"ChildWidgetProperties", value: Object): void;
            get(property:"ChildWidgetProperties"): Object;
            watch(property:"ChildWidgetProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Indicates that this widget is going to call resize() on its
             * children widgets, setting their size, when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * either 'horizontal' or vertical; indicates whether the children are
             * arranged side-by-side or up/down.
             * 
             */
            "orientation": string;
            set(property:"orientation", value: string): void;
            get(property:"orientation"): string;
            watch(property:"orientation", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Save splitter positions in a cookie
             * 
             */
            "persist": boolean;
            set(property:"persist", value: boolean): void;
            get(property:"persist"): boolean;
            watch(property:"persist", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Size in pixels of the bar between each child
             * 
             */
            "sizerWidth": number;
            set(property:"sizerWidth", value: number): void;
            get(property:"sizerWidth"): number;
            watch(property:"sizerWidth", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Add a child widget to the container
             * 
             * @param child a widget to add             
             * @param insertIndex               Optionalposition in the "stack" to add the child widget             
             */
            addChild(child: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Begin dragging the splitter between child[i] and child[i+1]
             * 
             * @param e             
             * @param i             
             */
            beginSizing(e: any, i: any): void;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Called on mousemove while dragging the splitter
             * 
             * @param e             
             */
            changeSizing(e: any): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * 
             */
            endSizing(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the index of this widget within its container parent.
             * It returns -1 if the parent does not exist, or if the parent
             * is not a dijit/_Container
             * 
             */
            getIndexInParent(): any;
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns null if this is the last child of the parent,
             * otherwise returns the next element sibling to the "right".
             * 
             */
            getNextSibling(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns null if this is the first child of the parent,
             * otherwise returns the next element sibling to the "left".
             * 
             */
            getPreviousSibling(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Do layout of panels
             * 
             */
            layout(): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Remove sizer, but only if widget is really our child and
             * we have at least one sizer to throw away
             * 
             * @param widget             
             */
            removeChild(widget: any): void;
            /**
             * 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:
             * 
             * Sets this._borderBox and this._contentBox to the new size of
             *  the widget.  Queries the current domNode size if necessary.
             * Calls layout() to resize contents (and maybe adjust child widgets).
             * 
             * @param changeSize               OptionalSets the widget to this margin-box size and position.May include any/all of the following properties:{w: int, h: int, l: int, t: int}             
             * @param resultSize               OptionalThe margin-box size of this widget after applying changeSize (ifchangeSize is specified).  If caller knows this size andpasses it in, we don't need to query the browser to get the size.{w: int, h: int}             
             */
            resize(changeSize: Object, resultSize: Object): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module SplitContainer {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/SplitContainer.ChildWidgetProperties.html
             *
             * These properties can be specified for the children of a SplitContainer.
             * 
             */
            interface ChildWidgetProperties {
                /**
                 * Minimum size (width or height) of a child of a SplitContainer.
                 * The value is relative to other children's sizeShare properties.
                 * 
                 */
                sizeMin: number;
                /**
                 * Size (width or height) of a child of a SplitContainer.
                 * The value is relative to other children's sizeShare properties.
                 * For example, if there are two children and each has sizeShare=10, then
                 * each takes up 50% of the available space.
                 * 
                 */
                sizeShare: number;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/StackContainer.html
         *
         * A container that has multiple children, but shows only
         * one child at a time
         * A container for widgets (ContentPanes, for example) That displays
         * only one Widget at a time.
         * 
         * Publishes topics [widgetId]-addChild, [widgetId]-removeChild, and [widgetId]-selectChild
         * 
         * Can be base class for container, Wizard, Show, etc.
         * 
         * See StackContainer.ChildWidgetProperties for details on the properties that can be set on
         * children of a StackContainer.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class StackContainer extends dijit.layout._LayoutWidget {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * These properties can be specified for the children of a StackContainer.
             * 
             */
            "ChildWidgetProperties": Object;
            set(property:"ChildWidgetProperties", value: Object): void;
            get(property:"ChildWidgetProperties"): Object;
            watch(property:"ChildWidgetProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If true, change the size of my currently displayed child to match my size
             * 
             */
            "doLayout": boolean;
            set(property:"doLayout", value: boolean): void;
            get(property:"doLayout"): boolean;
            watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Indicates that this widget is going to call resize() on its
             * children widgets, setting their size, when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Remembers the selected child across sessions
             * 
             */
            "persist": boolean;
            set(property:"persist", value: boolean): void;
            get(property:"persist"): boolean;
            watch(property:"persist", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * References the currently selected child widget, if any.
             * Adjust selected child with selectChild() method.
             * 
             */
            "selectedChildWidget": Object;
            set(property:"selectedChildWidget", value: Object): void;
            get(property:"selectedChildWidget"): Object;
            watch(property:"selectedChildWidget", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             * @param child             
             * @param insertIndex               Optional            
             */
            addChild(child: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Go back to previous page.
             * 
             */
            back(): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * 
             * @param preserveDom             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Advance to next page.
             * 
             */
            forward(): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the index of this widget within its container parent.
             * It returns -1 if the parent does not exist, or if the parent
             * is not a dijit/_Container
             * 
             */
            getIndexInParent(): any;
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns null if this is the last child of the parent,
             * otherwise returns the next element sibling to the "right".
             * 
             */
            getNextSibling(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns null if this is the first child of the parent,
             * otherwise returns the next element sibling to the "left".
             * 
             */
            getPreviousSibling(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            layout(): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * 
             */
            resize(): void;
            /**
             * Show the given widget (which must be one of my children)
             * 
             * @param page Reference to child widget or id of child widget             
             * @param animate             
             */
            selectChild(page: dijit._WidgetBase , animate: boolean): any;
            /**
             * Show the given widget (which must be one of my children)
             * 
             * @param page Reference to child widget or id of child widget             
             * @param animate             
             */
            selectChild(page: String, animate: boolean): any;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module StackContainer {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/StackContainer.ChildWidgetProperties.html
             *
             * These properties can be specified for the children of a StackContainer.
             * 
             */
            interface ChildWidgetProperties {
                /**
                 * True if user can close (destroy) this child, such as (for example) clicking the X on the tab.
                 * 
                 */
                closable: 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;
                /**
                 * CSS Class specifying icon to use in label associated with this pane.
                 * 
                 */
                iconClass: string;
                /**
                 * Specifies that this widget should be the initially displayed pane.
                 * Note: to change the selected child use dijit/layout/StackContainer.selectChild
                 * 
                 */
                selected: boolean;
                /**
                 * When true, display title of this widget as tab label etc., rather than just using
                 * icon specified in iconClass
                 * 
                 */
                showTitle: boolean;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/StackController.html
         *
         * Set of buttons to select a page in a dijit/layout/StackContainer
         * Monitors the specified StackContainer, and whenever a page is
         * added, deleted, or selected, updates itself accordingly.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class StackController extends dijit._Widget implements dijit._TemplatedMixin, dijit._Container {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * CSS class of [x] close icon, used by event delegation code to tell when close button was clicked
             * 
             */
            "buttonWidgetCloseClass": string;
            set(property:"buttonWidgetCloseClass", value: string): void;
            get(property:"buttonWidgetCloseClass"): string;
            watch(property:"buttonWidgetCloseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The id of the page container that I point to
             * 
             */
            "containerId": string;
            set(property:"containerId", value: string): void;
            get(property:"containerId"): string;
            watch(property:"containerId", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * The button widget to create to correspond to each page
             * 
             */
            buttonWidget(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             * @param preserveDom             
             */
            destroy(preserveDom?: any): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Returns the button corresponding to the pane w/the given id.
             * 
             * @param id             
             */
            pane2button(id: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             */
            StackButton(): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module StackController {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/StackController.StackButton.html
             *
             * Internal widget used by StackContainer.
             * The button-like or tab-like object you click to select or delete a page
             * 
             * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
             * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
             */
            class StackButton extends dijit.form.ToggleButton {
                constructor(params?: Object, srcNodeRef?: HTMLElement);
                /**
                 * True if mouse was pressed while over this widget, and hasn't been released yet
                 * 
                 */
                "active": boolean;
                set(property:"active", value: boolean): void;
                get(property:"active"): boolean;
                watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Corresponds to the native HTML <input> element's attribute.
                 * 
                 */
                "alt": string;
                set(property:"alt", value: string): void;
                get(property:"alt"): string;
                watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "aria-label": string;
                set(property:"aria-label", value: string): void;
                get(property:"aria-label"): string;
                watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Object to which attach points and events will be scoped.  Defaults
                 * to 'this'.
                 * 
                 */
                "attachScope": Object;
                set(property:"attachScope", value: Object): void;
                get(property:"attachScope"): Object;
                watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                 * for each XXX attribute to be mapped to the DOM.
                 * 
                 * attributeMap sets up a "binding" between attributes (aka properties)
                 * of the widget and the widget's DOM.
                 * Changes to widget attributes listed in attributeMap will be
                 * reflected into the DOM.
                 * 
                 * For example, calling set('title', 'hello')
                 * on a TitlePane will automatically cause the TitlePane's DOM to update
                 * with the new title.
                 * 
                 * attributeMap is a hash where the key is an attribute of the widget,
                 * and the value reflects a binding to a:
                 * 
                 * DOM node attribute
                 *   focus: {node: "focusNode", type: "attribute"}
                 * Maps this.focus to this.focusNode.focus
                 * 
                 * DOM node innerHTML
                 *   title: { node: "titleNode", type: "innerHTML" }
                 * Maps this.title to this.titleNode.innerHTML
                 * 
                 * DOM node innerText
                 *   title: { node: "titleNode", type: "innerText" }
                 * Maps this.title to this.titleNode.innerText
                 * 
                 * DOM node CSS class
                 *   myClass: { node: "domNode", type: "class" }
                 * Maps this.myClass to this.domNode.className
                 * 
                 * If the value is an array, then each element in the array matches one of the
                 * formats of the above list.
                 * 
                 * There are also some shorthands for backwards compatibility:
                 * 
                 * string --> { node: string, type: "attribute" }, for example:
                 * "focusNode" ---> { node: "focusNode", type: "attribute" }
                 * "" --> { node: "domNode", type: "attribute" }
                 * 
                 */
                "attributeMap": Object;
                set(property:"attributeMap", value: Object): void;
                get(property:"attributeMap"): Object;
                watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * 
                 */
                "baseClass": string;
                set(property:"baseClass", value: string): void;
                get(property:"baseClass"): string;
                watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Corresponds to the native HTML <input> element's attribute.
                 * In markup, specified as "checked='checked'" or just "checked".
                 * True if the button is depressed, or the checkbox is checked,
                 * or the radio button is selected, etc.
                 * 
                 */
                "checked": boolean;
                set(property:"checked", value: boolean): void;
                get(property:"checked"): boolean;
                watch(property:"checked", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * 
                 */
                "class": string;
                set(property:"class", value: string): void;
                get(property:"class"): string;
                watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * When true, display close button for this tab
                 * 
                 */
                "closeButton": boolean;
                set(property:"closeButton", value: boolean): void;
                get(property:"closeButton"): boolean;
                watch(property:"closeButton", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Designates where children of the source DOM node will be placed.
                 * "Children" in this case refers to both DOM nodes and widgets.
                 * For example, for myWidget:
                 * 
                 * <div data-dojo-type=myWidget>
                 *     <b> here's a plain DOM node
                 *     <span data-dojo-type=subWidget>and a widget</span>
                 *     <i> and another plain DOM node </i>
                 * </div>
                 * containerNode would point to:
                 * 
                 * <b> here's a plain DOM node
                 * <span data-dojo-type=subWidget>and a widget</span>
                 * <i> and another plain DOM node </i>
                 * In templated widgets, "containerNode" is set via a
                 * data-dojo-attach-point assignment.
                 * 
                 * containerNode must be defined for any widget that accepts innerHTML
                 * (like ContentPane or BorderContainer or even Button), and conversely
                 * is null for widgets that don't, like TextBox.
                 * 
                 */
                "containerNode": HTMLElement;
                set(property:"containerNode", value: HTMLElement): void;
                get(property:"containerNode"): HTMLElement;
                watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * Subclasses may define a cssStateNodes property that lists sub-nodes within the widget that
                 * need CSS classes applied on mouse hover/press and focus.
                 * 
                 * Each entry in this optional hash is a an attach-point name (like "upArrowButton") mapped to a CSS class name
                 * (like "dijitUpArrowButton"). Example:
                 * 
                 * {
                 *     "upArrowButton": "dijitUpArrowButton",
                 *     "downArrowButton": "dijitDownArrowButton"
                 * }
                 * The above will set the CSS class dijitUpArrowButton to the this.upArrowButton DOMNode when it
                 * 
                 * is hovered, etc.
                 * 
                 */
                "cssStateNodes": Object;
                set(property:"cssStateNodes", value: Object): void;
                get(property:"cssStateNodes"): Object;
                watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Bi-directional support, as defined by the HTML DIR
                 * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                 * default direction.
                 * 
                 */
                "dir": string;
                set(property:"dir", value: string): void;
                get(property:"dir"): string;
                watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Should this widget respond to user input?
                 * In markup, this is specified as "disabled='disabled'", or just "disabled".
                 * 
                 */
                "disabled": boolean;
                set(property:"disabled", value: boolean): void;
                get(property:"disabled"): boolean;
                watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * This is our visible representation of the widget! Other DOM
                 * Nodes may by assigned to other properties, usually through the
                 * template system's data-dojo-attach-point syntax, but the domNode
                 * property is the canonical "top level" node in widget UI.
                 * 
                 */
                "domNode": HTMLElement;
                set(property:"domNode", value: HTMLElement): void;
                get(property:"domNode"): HTMLElement;
                watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * This widget or a widget it contains has focus, or is "active" because
                 * it was recently clicked.
                 * 
                 */
                "focused": boolean;
                set(property:"focused", value: boolean): void;
                get(property:"focused"): boolean;
                watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * True if cursor is over this widget
                 * 
                 */
                "hovering": boolean;
                set(property:"hovering", value: boolean): void;
                get(property:"hovering"): boolean;
                watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Class to apply to DOMNode in button to make it display an icon
                 * 
                 */
                "iconClass": string;
                set(property:"iconClass", value: string): void;
                get(property:"iconClass"): string;
                watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * A unique, opaque ID string that can be assigned by users or by the
                 * system. If the developer passes an ID which is known not to be
                 * unique, the specified ID is ignored and the system-generated ID is
                 * used instead.
                 * 
                 */
                "id": string;
                set(property:"id", value: string): void;
                get(property:"id"): string;
                watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Fires onChange for each value change or only on demand
                 * 
                 */
                "intermediateChanges": boolean;
                set(property:"intermediateChanges", value: boolean): void;
                get(property:"intermediateChanges"): boolean;
                watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Content to display in button.
                 * 
                 */
                "label": string;
                set(property:"label", value: string): void;
                get(property:"label"): string;
                watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Rarely used.  Overrides the default Dojo locale used to render this widget,
                 * as defined by the HTML LANG attribute.
                 * Value must be among the list of locales specified during by the Dojo bootstrap,
                 * formatted according to RFC 3066 (like en-us).
                 * 
                 */
                "lang": string;
                set(property:"lang", value: string): void;
                get(property:"lang"): string;
                watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Name used when submitting form; same as "name" attribute or plain HTML elements
                 * 
                 */
                "name": string;
                set(property:"name", value: string): void;
                get(property:"name"): string;
                watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * The document this widget belongs to.  If not specified to constructor, will default to
                 * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                 * 
                 */
                "ownerDocument": Object;
                set(property:"ownerDocument", value: Object): void;
                get(property:"ownerDocument"): Object;
                watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * On focus, should this widget scroll into view?
                 * 
                 */
                "scrollOnFocus": boolean;
                set(property:"scrollOnFocus", value: boolean): void;
                get(property:"scrollOnFocus"): boolean;
                watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * 
                 */
                "searchContainerNode": boolean;
                set(property:"searchContainerNode", value: boolean): void;
                get(property:"searchContainerNode"): boolean;
                watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Set this to true to hide the label text and display only the icon.
                 * (If showLabel=false then iconClass must be specified.)
                 * Especially useful for toolbars.
                 * If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
                 * 
                 * The exception case is for computers in high-contrast mode, where the label
                 * will still be displayed, since the icon doesn't appear.
                 * 
                 */
                "showLabel": boolean;
                set(property:"showLabel", value: boolean): void;
                get(property:"showLabel"): boolean;
                watch(property:"showLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * pointer to original DOM node
                 * 
                 */
                "srcNodeRef": HTMLElement;
                set(property:"srcNodeRef", value: HTMLElement): void;
                get(property:"srcNodeRef"): HTMLElement;
                watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * HTML style attributes as cssText string or name/value hash
                 * 
                 */
                "style": string;
                set(property:"style", value: string): void;
                get(property:"style"): string;
                watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "tabIndex": string;
                set(property:"tabIndex", value: string): void;
                get(property:"tabIndex"): string;
                watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                 * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                 * 
                 */
                "templatePath": string;
                set(property:"templatePath", value: string): void;
                get(property:"templatePath"): string;
                watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "templateString": string;
                set(property:"templateString", value: string): void;
                get(property:"templateString"): string;
                watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * HTML title attribute.
                 * 
                 * For form widgets this specifies a tooltip to display when hovering over
                 * the widget (just like the native HTML title attribute).
                 * 
                 * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                 * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                 * interpreted as HTML.
                 * 
                 */
                "title": string;
                set(property:"title", value: string): void;
                get(property:"title"): string;
                watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                 * this specifies the tooltip to appear when the mouse is hovered over that text.
                 * 
                 */
                "tooltip": string;
                set(property:"tooltip", value: string): void;
                get(property:"tooltip"): string;
                watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Corresponds to the native HTML <input> element's attribute.
                 * 
                 */
                "type": string;
                set(property:"type", value: string): void;
                get(property:"type"): string;
                watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Corresponds to the native HTML <input> element's attribute.
                 * 
                 */
                "value": string;
                set(property:"value", value: string): void;
                get(property:"value"): string;
                watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: String, value: Object): any;
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: Object, value: Object): any;
                /**
                 * 
                 * @param evt             
                 */
                buildRendering(evt?: Event): void;
                /**
                 * Compare 2 values (as returned by get('value') for this widget).
                 * 
                 * @param val1             
                 * @param val2             
                 */
                compare(val1: any, val2: any): number;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: Function): any;
                /**
                 * Wrapper to setTimeout to avoid deferred functions executing
                 * after the originating widget has been destroyed.
                 * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                 * 
                 * @param fcn Function reference.             
                 * @param delay               OptionalDelay, defaults to 0.             
                 */
                defer(fcn: Function, delay: number): Object;
                /**
                 * Destroy this widget, but not its descendants.  Descendants means widgets inside of
                 * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
                 * 
                 * This method will also destroy internal widgets such as those created from a template,
                 * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
                 * 
                 * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
                 * depend on the current ability to destroy a widget without destroying its descendants.   Generally
                 * they should use destroyRecursive() for widgets with children.
                 * 
                 * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
                 */
                destroy(preserveDom?: boolean): void;
                /**
                 * Recursively destroy the children of this widget and their
                 * descendants.
                 * 
                 * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                 */
                destroyDescendants(preserveDom?: boolean): void;
                /**
                 * Destroy this widget and its descendants
                 * This is the generic "destructor" function that all widget users
                 * should call to cleanly discard with a widget. Once a widget is
                 * destroyed, it is removed from the manager object.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                 */
                destroyRecursive(preserveDom?: boolean): void;
                /**
                 * Destroys the DOM nodes associated with this widget.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                 */
                destroyRendering(preserveDom?: boolean): void;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Disconnects handle created by connect.
                 * 
                 * @param handle             
                 */
                disconnect(handle: any): void;
                /**
                 * Used by widgets to signal that a synthetic event occurred, ex:
                 * 
                 * myWidget.emit("attrmodified-selectedChildWidget", {}).
                 * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                 * Also calls onType() method, if present, and returns value from that method.
                 * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                 * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                 * 
                 * @param type             
                 * @param eventObj               Optional            
                 * @param callbackArgs               Optional            
                 */
                emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                /**
                 * Put focus on this widget
                 * 
                 */
                focus(): void;
                /**
                 * Get a property from a widget.
                 * Get a named property from a widget. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _getFooAttr(), calling:
                 * myWidget.get("foo") would be equivalent to calling
                 * widget._getFooAttr() and myWidget.get("bar")
                 * would be equivalent to the expression
                 * widget.bar2
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                 * is this widget.   Note that it does not return all descendants, but rather just direct children.
                 * Analogous to Node.childNodes,
                 * except containing widgets rather than DOMNodes.
                 * 
                 * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                 * outside of this.containerNode.
                 * 
                 * Note that the array returned is a simple array.  Application code should not assume
                 * existence of methods like forEach().
                 * 
                 */
                getChildren(): any[];
                /**
                 * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                 * This method should generally be avoided as it returns widgets declared in templates, which are
                 * supposed to be internal/hidden, but it's left here for back-compat reasons.
                 * 
                 */
                getDescendants(): any[];
                /**
                 * Returns the parent widget of this widget.
                 * 
                 */
                getParent(): any;
                /**
                 * Deprecated.  Use get('value') instead.
                 * 
                 */
                getValue(): any;
                /**
                 * Return true if this widget can currently be focused
                 * and false if not
                 * 
                 */
                isFocusable(): any;
                /**
                 * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                 * 
                 */
                isLeftToRight(): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: String, func: Function): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: Function, func: Function): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: number): any;
                /**
                 * 
                 */
                postCreate(): void;
                /**
                 * 
                 */
                postMixInProperties(): void;
                /**
                 * Reset the widget's value to what it was at initialization time
                 * 
                 */
                reset(): void;
                /**
                 * Set a property on a widget
                 * Sets named properties on a widget which may potentially be handled by a
                 * setter in the widget.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _setFooAttr(), calling
                 * myWidget.set("foo", "Howdy!") would be equivalent to calling
                 * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                 * would be equivalent to the statement widget.bar = 3;
                 * 
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * myWidget.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * });
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: any, value: any): any;
                /**
                 * Deprecated.  Use set() instead.
                 * 
                 * @param attr             
                 * @param value             
                 */
                setAttribute(attr: String, value: any): void;
                /**
                 * Deprecated.  Use set('checked', true/false) instead.
                 * 
                 * @param checked             
                 */
                setChecked(checked: boolean): void;
                /**
                 * Deprecated.  Use set('disabled', ...) instead.
                 * 
                 * @param disabled             
                 */
                setDisabled(disabled: boolean): void;
                /**
                 * Deprecated.  Use set('label', ...) instead.
                 * 
                 * @param content             
                 */
                setLabel(content: String): void;
                /**
                 * Deprecated.  Use set('value', ...) instead.
                 * 
                 * @param value             
                 */
                setValue(value: String): void;
                /**
                 * Processing after the DOM fragment is added to the document
                 * Called after a widget and its children have been created and added to the page,
                 * and all related widgets have finished their create() cycle, up through postCreate().
                 * 
                 * Note that startup() may be called while the widget is still hidden, for example if the widget is
                 * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
                 * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
                 * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
                 * 
                 */
                startup(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                 * 
                 * Subscribes to the specified topic and calls the specified method
                 * of this object and registers for unsubscribe() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.subscribe, except with the
                 * implicit use of this widget as the target object.
                 * 
                 * @param t The topic             
                 * @param method The callback             
                 */
                subscribe(t: String, method: Function): any;
                /**
                 * Returns a string that represents the widget.
                 * When a widget is cast to a string, this method will be used to generate the
                 * output. Currently, it does not implement any sort of reversible
                 * serialization.
                 * 
                 */
                toString(): string;
                /**
                 * Deprecated. Override destroy() instead to implement custom widget tear-down
                 * behavior.
                 * 
                 */
                uninitialize(): boolean;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Unsubscribes handle created by this.subscribe.
                 * Also removes handle from this widget's list of subscriptions
                 * 
                 * @param handle             
                 */
                unsubscribe(handle: Object): void;
                /**
                 * Watches a property for changes
                 * 
                 * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                 * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                 */
                watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                /**
                 * Static method to get a template based on the templatePath or
                 * templateString key
                 */
                getCachedTemplate(): any;
                /**
                 * Called when the widget stops being "active" because
                 * focus moved to something outside of it, or the user
                 * clicked somewhere outside of it, or the widget was
                 * hidden.
                 * 
                 */
                onBlur(): void;
                /**
                 * Callback when this widget's value is changed.
                 * 
                 * @param newValue             
                 */
                onChange(newValue: any): void;
                /**
                 * Connect to this function to receive notifications of mouse click events.
                 * 
                 * @param event mouse Event             
                 */
                onClick(event: Event): boolean;
                /**
                 * Called when this widget is being displayed as a popup (ex: a Calendar popped
                 * up from a DateTextBox), and it is hidden.
                 * This is called from the dijit.popup code, and should not be called directly.
                 * 
                 * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                 * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                 * 
                 */
                onClose(): boolean;
                /**
                 * Connect to this function to receive notifications of mouse double click events.
                 * 
                 * @param event mouse Event             
                 */
                onDblClick(event: any): void;
                /**
                 * Called when the widget becomes "active" because
                 * it or a widget inside of it either has focus, or has recently
                 * been clicked.
                 * 
                 */
                onFocus(): void;
                /**
                 * Called when another widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onHide(): void;
                /**
                 * Connect to this function to receive notifications of keys being pressed down.
                 * 
                 * @param event key Event             
                 */
                onKeyDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of printable keys being typed.
                 * 
                 * @param event key Event             
                 */
                onKeyPress(event: any): void;
                /**
                 * Connect to this function to receive notifications of keys being released.
                 * 
                 * @param event key Event             
                 */
                onKeyUp(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is pressed down.
                 * 
                 * @param event mouse Event             
                 */
                onMouseDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseEnter(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseLeave(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseMove(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOut(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOver(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is released.
                 * 
                 * @param event mouse Event             
                 */
                onMouseUp(event: any): void;
                /**
                 * Called when this widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onShow(): void;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/TabContainer.html
         *
         * A Container with tabs to select each child (only one of which is displayed at a time).
         * A TabContainer is a container that has multiple panes, but shows only
         * one pane at a time.  There are a set of tabs corresponding to each pane,
         * where each tab has the name (aka title) of the pane, and optionally a close button.
         * 
         * See StackContainer.ChildWidgetProperties for details on the properties that can be set on
         * children of a TabContainer.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class TabContainer extends dijit.layout._TabContainerBase {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * An optional parameter to override the widget used to display the tab labels
             * 
             */
            "controllerWidget": Object;
            set(property:"controllerWidget", value: Object): void;
            get(property:"controllerWidget"): Object;
            watch(property:"controllerWidget", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * If true, change the size of my currently displayed child to match my size
             * 
             */
            "doLayout": boolean;
            set(property:"doLayout", value: boolean): void;
            get(property:"doLayout"): boolean;
            watch(property:"doLayout", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Indicates that this widget is going to call resize() on its
             * children widgets, setting their size, when they become visible.
             * 
             */
            "isLayoutContainer": boolean;
            set(property:"isLayoutContainer", value: boolean): void;
            get(property:"isLayoutContainer"): boolean;
            watch(property:"isLayoutContainer", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 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;
            set(property:"nested", value: boolean): void;
            get(property:"nested"): boolean;
            watch(property:"nested", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Remembers the selected child across sessions
             * 
             */
            "persist": boolean;
            set(property:"persist", value: boolean): void;
            get(property:"persist"): boolean;
            watch(property:"persist", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * References the currently selected child widget, if any.
             * Adjust selected child with selectChild() method.
             * 
             */
            "selectedChildWidget": Object;
            set(property:"selectedChildWidget", value: Object): void;
            get(property:"selectedChildWidget"): Object;
            watch(property:"selectedChildWidget", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines where tabs go relative to tab content.
             * "top", "bottom", "left-h", "right-h"
             * 
             */
            "tabPosition": string;
            set(property:"tabPosition", value: string): void;
            get(property:"tabPosition"): string;
            watch(property:"tabPosition", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 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;
            set(property:"tabStrip", value: boolean): void;
            get(property:"tabStrip"): boolean;
            watch(property:"tabStrip", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * True if a menu should be used to select tabs when they are too
             * wide to fit the TabContainer, false otherwise.
             * 
             */
            "useMenu": boolean;
            set(property:"useMenu", value: boolean): void;
            get(property:"useMenu"): boolean;
            watch(property:"useMenu", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if a slider should be used to select tabs when they are too
             * wide to fit the TabContainer, false otherwise.
             * 
             */
            "useSlider": boolean;
            set(property:"useSlider", value: boolean): void;
            get(property:"useSlider"): boolean;
            watch(property:"useSlider", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * 
             * @param child             
             * @param insertIndex               Optional            
             */
            addChild(child: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Go back to previous page.
             * 
             */
            back(): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             * @param preserveDom             
             */
            destroy(preserveDom?: any): void;
            /**
             * 
             * @param preserveDom             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Advance to next page.
             * 
             */
            forward(): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the index of this widget within its container parent.
             * It returns -1 if the parent does not exist, or if the parent
             * is not a dijit/_Container
             * 
             */
            getIndexInParent(): any;
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns null if this is the last child of the parent,
             * otherwise returns the next element sibling to the "right".
             * 
             */
            getNextSibling(): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns null if this is the first child of the parent,
             * otherwise returns the next element sibling to the "left".
             * 
             */
            getPreviousSibling(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             */
            layout(): void;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * 
             */
            resize(): void;
            /**
             * Show the given widget (which must be one of my children)
             * 
             * @param page Reference to child widget or id of child widget             
             * @param animate             
             */
            selectChild(page: dijit._WidgetBase , animate: boolean): any;
            /**
             * Show the given widget (which must be one of my children)
             * 
             * @param page Reference to child widget or id of child widget             
             * @param animate             
             */
            selectChild(page: String, animate: boolean): any;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/TabController.html
         *
         * Set of tabs (the things with titles and a close button, that you click to show a tab panel).
         * Used internally by dijit/layout/TabContainer.
         * Lets the user select the currently shown pane in a TabContainer or StackContainer.
         * TabController also monitors the TabContainer, and whenever a pane is
         * added or deleted updates itself accordingly.
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
         */
        class TabController extends dijit.layout.StackController {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Class of [x] close icon, used by event delegation code to tell when close button was clicked
             * 
             */
            "buttonWidgetCloseClass": string;
            set(property:"buttonWidgetCloseClass", value: string): void;
            get(property:"buttonWidgetCloseClass"): string;
            watch(property:"buttonWidgetCloseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The id of the page container that I point to
             * 
             */
            "containerId": string;
            set(property:"containerId", value: string): void;
            get(property:"containerId"): string;
            watch(property:"containerId", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines where tabs go relative to the content.
             * "top", "bottom", "left-h", "right-h"
             * 
             */
            "tabPosition": string;
            set(property:"tabPosition", value: string): void;
            get(property:"tabPosition"): string;
            watch(property:"tabPosition", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Makes the given widget a child of this widget.
             * Inserts specified child widget's dom node as a child of this widget's
             * container node, and possibly does other processing (such as layout).
             * 
             * @param widget             
             * @param insertIndex               Optional            
             */
            addChild(widget: dijit._WidgetBase, insertIndex: number): void;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * Construct the UI for this widget, setting this.domNode.
             * Most widgets will mixin dijit._TemplatedMixin, which implements this method.
             * 
             */
            buildRendering(): void;
            /**
             * The tab widget to create to correspond to each page
             * 
             */
            buttonWidget(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * 
             * @param preserveDom             
             */
            destroy(preserveDom?: any): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Gets the index of the child in this container or -1 if not found
             * 
             * @param child             
             */
            getIndexOfChild(child: dijit._WidgetBase): any;
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Returns true if widget has child widgets, i.e. if this.containerNode contains widgets.
             * 
             */
            hasChildren(): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * 
             * @param type protected             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Returns the button corresponding to the pane w/the given id.
             * 
             * @param id             
             */
            pane2button(id: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: dijit._WidgetBase): void;
            /**
             * Removes the passed widget instance from this widget but does
             * not destroy it.  You can also pass in an integer indicating
             * the index within the container to remove (ie, removeChild(5) removes the sixth widget).
             * 
             * @param widget             
             */
            removeChild(widget: number): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * 
             */
            TabButton(): void;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
        }
        module TabController {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/TabController.TabButton.html
             *
             * 
             * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
             * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified:use srcNodeRef.innerHTML as my contentsif this is a behavioral widget then apply behavior to that srcNodeRefotherwise, replace srcNodeRef with my generated DOM tree     
             */
            class TabButton extends dijit.form.ToggleButton {
                constructor(params?: Object, srcNodeRef?: HTMLElement);
                /**
                 * True if mouse was pressed while over this widget, and hasn't been released yet
                 * 
                 */
                "active": boolean;
                set(property:"active", value: boolean): void;
                get(property:"active"): boolean;
                watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Corresponds to the native HTML <input> element's attribute.
                 * 
                 */
                "alt": string;
                set(property:"alt", value: string): void;
                get(property:"alt"): string;
                watch(property:"alt", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "aria-label": string;
                set(property:"aria-label", value: string): void;
                get(property:"aria-label"): string;
                watch(property:"aria-label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Object to which attach points and events will be scoped.  Defaults
                 * to 'this'.
                 * 
                 */
                "attachScope": Object;
                set(property:"attachScope", value: Object): void;
                get(property:"attachScope"): Object;
                watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
                 * for each XXX attribute to be mapped to the DOM.
                 * 
                 * attributeMap sets up a "binding" between attributes (aka properties)
                 * of the widget and the widget's DOM.
                 * Changes to widget attributes listed in attributeMap will be
                 * reflected into the DOM.
                 * 
                 * For example, calling set('title', 'hello')
                 * on a TitlePane will automatically cause the TitlePane's DOM to update
                 * with the new title.
                 * 
                 * attributeMap is a hash where the key is an attribute of the widget,
                 * and the value reflects a binding to a:
                 * 
                 * DOM node attribute
                 *   focus: {node: "focusNode", type: "attribute"}
                 * Maps this.focus to this.focusNode.focus
                 * 
                 * DOM node innerHTML
                 *   title: { node: "titleNode", type: "innerHTML" }
                 * Maps this.title to this.titleNode.innerHTML
                 * 
                 * DOM node innerText
                 *   title: { node: "titleNode", type: "innerText" }
                 * Maps this.title to this.titleNode.innerText
                 * 
                 * DOM node CSS class
                 *   myClass: { node: "domNode", type: "class" }
                 * Maps this.myClass to this.domNode.className
                 * 
                 * If the value is an array, then each element in the array matches one of the
                 * formats of the above list.
                 * 
                 * There are also some shorthands for backwards compatibility:
                 * 
                 * string --> { node: string, type: "attribute" }, for example:
                 * "focusNode" ---> { node: "focusNode", type: "attribute" }
                 * "" --> { node: "domNode", type: "attribute" }
                 * 
                 */
                "attributeMap": Object;
                set(property:"attributeMap", value: Object): void;
                get(property:"attributeMap"): Object;
                watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * The CSS class applied to the domNode.
                 * 
                 */
                "baseClass": string;
                set(property:"baseClass", value: string): void;
                get(property:"baseClass"): string;
                watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Corresponds to the native HTML <input> element's attribute.
                 * In markup, specified as "checked='checked'" or just "checked".
                 * True if the button is depressed, or the checkbox is checked,
                 * or the radio button is selected, etc.
                 * 
                 */
                "checked": boolean;
                set(property:"checked", value: boolean): void;
                get(property:"checked"): boolean;
                watch(property:"checked", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * 
                 */
                "class": string;
                set(property:"class", value: string): void;
                get(property:"class"): string;
                watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * When true, display close button for this tab
                 * 
                 */
                "closeButton": boolean;
                set(property:"closeButton", value: boolean): void;
                get(property:"closeButton"): boolean;
                watch(property:"closeButton", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Designates where children of the source DOM node will be placed.
                 * "Children" in this case refers to both DOM nodes and widgets.
                 * For example, for myWidget:
                 * 
                 * <div data-dojo-type=myWidget>
                 *     <b> here's a plain DOM node
                 *     <span data-dojo-type=subWidget>and a widget</span>
                 *     <i> and another plain DOM node </i>
                 * </div>
                 * containerNode would point to:
                 * 
                 * <b> here's a plain DOM node
                 * <span data-dojo-type=subWidget>and a widget</span>
                 * <i> and another plain DOM node </i>
                 * In templated widgets, "containerNode" is set via a
                 * data-dojo-attach-point assignment.
                 * 
                 * containerNode must be defined for any widget that accepts innerHTML
                 * (like ContentPane or BorderContainer or even Button), and conversely
                 * is null for widgets that don't, like TextBox.
                 * 
                 */
                "containerNode": HTMLElement;
                set(property:"containerNode", value: HTMLElement): void;
                get(property:"containerNode"): HTMLElement;
                watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * 
                 */
                "cssStateNodes": Object;
                set(property:"cssStateNodes", value: Object): void;
                get(property:"cssStateNodes"): Object;
                watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * Bi-directional support, as defined by the HTML DIR
                 * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
                 * default direction.
                 * 
                 */
                "dir": string;
                set(property:"dir", value: string): void;
                get(property:"dir"): string;
                watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Should this widget respond to user input?
                 * In markup, this is specified as "disabled='disabled'", or just "disabled".
                 * 
                 */
                "disabled": boolean;
                set(property:"disabled", value: boolean): void;
                get(property:"disabled"): boolean;
                watch(property:"disabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * This is our visible representation of the widget! Other DOM
                 * Nodes may by assigned to other properties, usually through the
                 * template system's data-dojo-attach-point syntax, but the domNode
                 * property is the canonical "top level" node in widget UI.
                 * 
                 */
                "domNode": HTMLElement;
                set(property:"domNode", value: HTMLElement): void;
                get(property:"domNode"): HTMLElement;
                watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * This widget or a widget it contains has focus, or is "active" because
                 * it was recently clicked.
                 * 
                 */
                "focused": boolean;
                set(property:"focused", value: boolean): void;
                get(property:"focused"): boolean;
                watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * True if cursor is over this widget
                 * 
                 */
                "hovering": boolean;
                set(property:"hovering", value: boolean): void;
                get(property:"hovering"): boolean;
                watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Class to apply to DOMNode in button to make it display an icon
                 * 
                 */
                "iconClass": string;
                set(property:"iconClass", value: string): void;
                get(property:"iconClass"): string;
                watch(property:"iconClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * A unique, opaque ID string that can be assigned by users or by the
                 * system. If the developer passes an ID which is known not to be
                 * unique, the specified ID is ignored and the system-generated ID is
                 * used instead.
                 * 
                 */
                "id": string;
                set(property:"id", value: string): void;
                get(property:"id"): string;
                watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Fires onChange for each value change or only on demand
                 * 
                 */
                "intermediateChanges": boolean;
                set(property:"intermediateChanges", value: boolean): void;
                get(property:"intermediateChanges"): boolean;
                watch(property:"intermediateChanges", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Content to display in button.
                 * 
                 */
                "label": string;
                set(property:"label", value: string): void;
                get(property:"label"): string;
                watch(property:"label", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Rarely used.  Overrides the default Dojo locale used to render this widget,
                 * as defined by the HTML LANG attribute.
                 * Value must be among the list of locales specified during by the Dojo bootstrap,
                 * formatted according to RFC 3066 (like en-us).
                 * 
                 */
                "lang": string;
                set(property:"lang", value: string): void;
                get(property:"lang"): string;
                watch(property:"lang", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Name used when submitting form; same as "name" attribute or plain HTML elements
                 * 
                 */
                "name": string;
                set(property:"name", value: string): void;
                get(property:"name"): string;
                watch(property:"name", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * The document this widget belongs to.  If not specified to constructor, will default to
                 * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
                 * 
                 */
                "ownerDocument": Object;
                set(property:"ownerDocument", value: Object): void;
                get(property:"ownerDocument"): Object;
                watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                /**
                 * 
                 */
                "scrollOnFocus": boolean;
                set(property:"scrollOnFocus", value: boolean): void;
                get(property:"scrollOnFocus"): boolean;
                watch(property:"scrollOnFocus", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * 
                 */
                "searchContainerNode": boolean;
                set(property:"searchContainerNode", value: boolean): void;
                get(property:"searchContainerNode"): boolean;
                watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * Set this to true to hide the label text and display only the icon.
                 * (If showLabel=false then iconClass must be specified.)
                 * Especially useful for toolbars.
                 * If showLabel=true, the label will become the title (a.k.a. tooltip/hint) of the icon.
                 * 
                 * The exception case is for computers in high-contrast mode, where the label
                 * will still be displayed, since the icon doesn't appear.
                 * 
                 */
                "showLabel": boolean;
                set(property:"showLabel", value: boolean): void;
                get(property:"showLabel"): boolean;
                watch(property:"showLabel", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                /**
                 * pointer to original DOM node
                 * 
                 */
                "srcNodeRef": HTMLElement;
                set(property:"srcNodeRef", value: HTMLElement): void;
                get(property:"srcNodeRef"): HTMLElement;
                watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
                /**
                 * HTML style attributes as cssText string or name/value hash
                 * 
                 */
                "style": string;
                set(property:"style", value: string): void;
                get(property:"style"): string;
                watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "tabIndex": string;
                set(property:"tabIndex", value: string): void;
                get(property:"tabIndex"): string;
                watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Path to template (HTML file) for this widget relative to dojo.baseUrl.
                 * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
                 * 
                 */
                "templatePath": string;
                set(property:"templatePath", value: string): void;
                get(property:"templatePath"): string;
                watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * 
                 */
                "templateString": string;
                set(property:"templateString", value: string): void;
                get(property:"templateString"): string;
                watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * HTML title attribute.
                 * 
                 * For form widgets this specifies a tooltip to display when hovering over
                 * the widget (just like the native HTML title attribute).
                 * 
                 * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
                 * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
                 * interpreted as HTML.
                 * 
                 */
                "title": string;
                set(property:"title", value: string): void;
                get(property:"title"): string;
                watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
                 * this specifies the tooltip to appear when the mouse is hovered over that text.
                 * 
                 */
                "tooltip": string;
                set(property:"tooltip", value: string): void;
                get(property:"tooltip"): string;
                watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Corresponds to the native HTML <input> element's attribute.
                 * 
                 */
                "type": string;
                set(property:"type", value: string): void;
                get(property:"type"): string;
                watch(property:"type", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * Corresponds to the native HTML <input> element's attribute.
                 * 
                 */
                "value": string;
                set(property:"value", value: string): void;
                get(property:"value"): string;
                watch(property:"value", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: String, value: Object): any;
                /**
                 * This method is deprecated, use get() or set() directly.
                 * 
                 * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
                 * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
                 */
                attr(name: Object, value: Object): any;
                /**
                 * 
                 */
                buildRendering(): void;
                /**
                 * Compare 2 values (as returned by get('value') for this widget).
                 * 
                 * @param val1             
                 * @param val2             
                 */
                compare(val1: any, val2: any): number;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: String): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: String, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: Object, event: Function, method: Function): any;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
                 * 
                 * Connects specified obj/event to specified method of this object
                 * and registers for disconnect() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.connect, except with the
                 * implicit use of this widget as the target object.
                 * Events connected with this.connect are disconnected upon
                 * destruction.
                 * 
                 * @param obj             
                 * @param event             
                 * @param method             
                 */
                connect(obj: any, event: Function, method: Function): any;
                /**
                 * Wrapper to setTimeout to avoid deferred functions executing
                 * after the originating widget has been destroyed.
                 * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
                 * 
                 * @param fcn Function reference.             
                 * @param delay               OptionalDelay, defaults to 0.             
                 */
                defer(fcn: Function, delay: number): Object;
                /**
                 * Destroy this widget, but not its descendants.  Descendants means widgets inside of
                 * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
                 * 
                 * This method will also destroy internal widgets such as those created from a template,
                 * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
                 * 
                 * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
                 * depend on the current ability to destroy a widget without destroying its descendants.   Generally
                 * they should use destroyRecursive() for widgets with children.
                 * 
                 * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
                 */
                destroy(preserveDom?: boolean): void;
                /**
                 * Recursively destroy the children of this widget and their
                 * descendants.
                 * 
                 * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
                 */
                destroyDescendants(preserveDom?: boolean): void;
                /**
                 * Destroy this widget and its descendants
                 * This is the generic "destructor" function that all widget users
                 * should call to cleanly discard with a widget. Once a widget is
                 * destroyed, it is removed from the manager object.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
                 */
                destroyRecursive(preserveDom?: boolean): void;
                /**
                 * Destroys the DOM nodes associated with this widget.
                 * 
                 * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
                 */
                destroyRendering(preserveDom?: boolean): void;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Disconnects handle created by connect.
                 * 
                 * @param handle             
                 */
                disconnect(handle: any): void;
                /**
                 * Used by widgets to signal that a synthetic event occurred, ex:
                 * 
                 * myWidget.emit("attrmodified-selectedChildWidget", {}).
                 * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
                 * Also calls onType() method, if present, and returns value from that method.
                 * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
                 * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
                 * 
                 * @param type             
                 * @param eventObj               Optional            
                 * @param callbackArgs               Optional            
                 */
                emit(type: String, eventObj: Object, callbackArgs: any[]): any;
                /**
                 * Put focus on this widget
                 * 
                 */
                focus(): void;
                /**
                 * Get a property from a widget.
                 * Get a named property from a widget. The property may
                 * potentially be retrieved via a getter method. If no getter is defined, this
                 * just retrieves the object's property.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _getFooAttr(), calling:
                 * myWidget.get("foo") would be equivalent to calling
                 * widget._getFooAttr() and myWidget.get("bar")
                 * would be equivalent to the expression
                 * widget.bar2
                 * 
                 * @param name The property to get.             
                 */
                get(name: any): any;
                /**
                 * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
                 * is this widget.   Note that it does not return all descendants, but rather just direct children.
                 * Analogous to Node.childNodes,
                 * except containing widgets rather than DOMNodes.
                 * 
                 * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
                 * outside of this.containerNode.
                 * 
                 * Note that the array returned is a simple array.  Application code should not assume
                 * existence of methods like forEach().
                 * 
                 */
                getChildren(): any[];
                /**
                 * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
                 * This method should generally be avoided as it returns widgets declared in templates, which are
                 * supposed to be internal/hidden, but it's left here for back-compat reasons.
                 * 
                 */
                getDescendants(): any[];
                /**
                 * Returns the parent widget of this widget.
                 * 
                 */
                getParent(): any;
                /**
                 * Deprecated.  Use get('value') instead.
                 * 
                 */
                getValue(): any;
                /**
                 * Return true if this widget can currently be focused
                 * and false if not
                 * 
                 */
                isFocusable(): any;
                /**
                 * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
                 * 
                 */
                isLeftToRight(): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: String, func: Function): any;
                /**
                 * 
                 * @param type protected             
                 * @param func             
                 */
                on(type: Function, func: Function): any;
                /**
                 * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
                 * already removed/destroyed manually.
                 * 
                 */
                own(): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: String): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: String, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: HTMLElement, position: number): any;
                /**
                 * Place this widget somewhere in the DOM based
                 * on standard domConstruct.place() conventions.
                 * A convenience function provided in all _Widgets, providing a simple
                 * shorthand mechanism to put an existing (or newly created) Widget
                 * somewhere in the dom, and allow chaining.
                 * 
                 * @param reference Widget, DOMNode, or id of widget or DOMNode             
                 * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
                 */
                placeAt(reference: dijit._WidgetBase, position: number): any;
                /**
                 * 
                 */
                postCreate(): void;
                /**
                 * 
                 */
                postMixInProperties(): void;
                /**
                 * Reset the widget's value to what it was at initialization time
                 * 
                 */
                reset(): void;
                /**
                 * Set a property on a widget
                 * Sets named properties on a widget which may potentially be handled by a
                 * setter in the widget.
                 * 
                 * For example, if the widget has properties foo and bar
                 * and a method named _setFooAttr(), calling
                 * myWidget.set("foo", "Howdy!") would be equivalent to calling
                 * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
                 * would be equivalent to the statement widget.bar = 3;
                 * 
                 * set() may also be called with a hash of name/value pairs, ex:
                 * 
                 * myWidget.set({
                 *     foo: "Howdy",
                 *     bar: 3
                 * });
                 * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
                 * 
                 * @param name The property to set.             
                 * @param value The value to set in the property.             
                 */
                set(name: any, value: any): any;
                /**
                 * Deprecated.  Use set() instead.
                 * 
                 * @param attr             
                 * @param value             
                 */
                setAttribute(attr: String, value: any): void;
                /**
                 * Deprecated.  Use set('checked', true/false) instead.
                 * 
                 * @param checked             
                 */
                setChecked(checked: boolean): void;
                /**
                 * Deprecated.  Use set('disabled', ...) instead.
                 * 
                 * @param disabled             
                 */
                setDisabled(disabled: boolean): void;
                /**
                 * Deprecated.  Use set('label', ...) instead.
                 * 
                 * @param content             
                 */
                setLabel(content: String): void;
                /**
                 * Deprecated.  Use set('value', ...) instead.
                 * 
                 * @param value             
                 */
                setValue(value: String): void;
                /**
                 * 
                 */
                startup(): void;
                /**
                 * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
                 * 
                 * Subscribes to the specified topic and calls the specified method
                 * of this object and registers for unsubscribe() on widget destroy.
                 * 
                 * Provide widget-specific analog to dojo.subscribe, except with the
                 * implicit use of this widget as the target object.
                 * 
                 * @param t The topic             
                 * @param method The callback             
                 */
                subscribe(t: String, method: Function): any;
                /**
                 * Returns a string that represents the widget.
                 * When a widget is cast to a string, this method will be used to generate the
                 * output. Currently, it does not implement any sort of reversible
                 * serialization.
                 * 
                 */
                toString(): string;
                /**
                 * Deprecated. Override destroy() instead to implement custom widget tear-down
                 * behavior.
                 * 
                 */
                uninitialize(): boolean;
                /**
                 * Deprecated, will be removed in 2.0, use handle.remove() instead.
                 * 
                 * Unsubscribes handle created by this.subscribe.
                 * Also removes handle from this widget's list of subscriptions
                 * 
                 * @param handle             
                 */
                unsubscribe(handle: Object): void;
                /**
                 * Watches a property for changes
                 * 
                 * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
                 * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
                 */
                watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
                /**
                 * Static method to get a template based on the templatePath or
                 * templateString key
                 */
                getCachedTemplate(): any;
                /**
                 * Called when the widget stops being "active" because
                 * focus moved to something outside of it, or the user
                 * clicked somewhere outside of it, or the widget was
                 * hidden.
                 * 
                 */
                onBlur(): void;
                /**
                 * Callback when this widget's value is changed.
                 * 
                 * @param newValue             
                 */
                onChange(newValue: any): void;
                /**
                 * Connect to this function to receive notifications of mouse click events.
                 * 
                 * @param event mouse Event             
                 */
                onClick(event: Event): boolean;
                /**
                 * Called when this widget is being displayed as a popup (ex: a Calendar popped
                 * up from a DateTextBox), and it is hidden.
                 * This is called from the dijit.popup code, and should not be called directly.
                 * 
                 * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
                 * Callback if a user tries to close the child.   Child will be closed if this function returns true.
                 * 
                 */
                onClose(): boolean;
                /**
                 * Connect to this function to receive notifications of mouse double click events.
                 * 
                 * @param event mouse Event             
                 */
                onDblClick(event: any): void;
                /**
                 * Called when the widget becomes "active" because
                 * it or a widget inside of it either has focus, or has recently
                 * been clicked.
                 * 
                 */
                onFocus(): void;
                /**
                 * Called when another widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onHide(): void;
                /**
                 * Connect to this function to receive notifications of keys being pressed down.
                 * 
                 * @param event key Event             
                 */
                onKeyDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of printable keys being typed.
                 * 
                 * @param event key Event             
                 */
                onKeyPress(event: any): void;
                /**
                 * Connect to this function to receive notifications of keys being released.
                 * 
                 * @param event key Event             
                 */
                onKeyUp(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is pressed down.
                 * 
                 * @param event mouse Event             
                 */
                onMouseDown(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseEnter(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseLeave(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseMove(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOut(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
                 * 
                 * @param event mouse Event             
                 */
                onMouseOver(event: any): void;
                /**
                 * Connect to this function to receive notifications of when the mouse button is released.
                 * 
                 * @param event mouse Event             
                 */
                onMouseUp(event: any): void;
                /**
                 * Called when this widget becomes the selected pane in a
                 * dijit/layout/TabContainer, dijit/layout/StackContainer,
                 * dijit/layout/AccordionContainer, etc.
                 * 
                 * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
                 * 
                 */
                onShow(): void;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/layout/utils.html
         *
         * Utility functions for doing layout
         * 
         */
        interface utils {
            /**
             * Layout a bunch of child dom nodes within a parent dom node
             * 
             * @param container parent node             
             * @param dim {l, t, w, h} object specifying dimensions of container into which to place children             
             * @param children An array of Widgets or at least objects containing:domNode: pointer to DOM node to positionregion or layoutAlign: position to place DOM noderesize(): (optional) method to set size of nodeid: (optional) Id of widgets, referenced from resize object, below.The widgets in this array should be ordered according to how they should be laid out(each element will be processed in order, and take up as much remaining space as needed),with the center widget last.             
             * @param changedRegionId               OptionalIf specified, the slider for the region with the specified id has been dragged, and thusthe region's height or width should be adjusted according to changedRegionSize             
             * @param changedRegionSize               OptionalSee changedRegionId.             
             */
            layoutChildren(container: HTMLElement, dim: Object, children: dijit._WidgetBase[], changedRegionId: String, changedRegionSize: number): void;
            /**
             * Given the margin-box size of a node, return its content box size.
             * Functions like domGeometry.contentBox() but is more reliable since it doesn't have
             * to wait for the browser to compute sizes.
             * 
             * @param node             
             * @param mb             
             */
            marginBox2contentBox(node: HTMLElement, mb: Object): Object;
        }
    }

    module robot {
    }

    module robotx {
    }

    module tree {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/tree/_dndContainer.html
         *
         * This is a base class for dijit/tree/_dndSelector, and isn't meant to be used directly.
         * It's modeled after dojo/dnd/Container.
         * 
         * @param tree Node or node's id to build the container on     
         * @param params A dict of parameters, which gets mixed into the object     
         */
        class _dndContainer {
            constructor(tree: HTMLElement, params: Object);
            /**
             * The currently hovered TreeNode.  Not set to anything for keyboard operation.  (TODO: change?)
             * 
             */
            "current": Object;
            /**
             * Prepares this object to be garbage-collected
             * 
             */
            destroy(): void;
            /**
             * Called when mouse is moved away from a TreeNode
             * 
             * @param widget             
             * @param evt             
             */
            onMouseOut(widget: dijit.Tree._TreeNode, evt: Event): void;
            /**
             * Called when mouse is moved over a TreeNode
             * 
             * @param widget             
             * @param evt             
             */
            onMouseOver(widget: dijit.Tree._TreeNode, evt: Event): void;
            /**
             * This function is called once, when mouse is out of our container
             * 
             */
            onOutEvent(): void;
            /**
             * This function is called once, when mouse is over our container
             * 
             */
            onOverEvent(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/tree/_dndSelector.html
         *
         * This is a base class for dijit/tree/dndSource, and isn't meant to be used directly.
         * It's based on dojo/dnd/Selector.
         * 
         */
        class _dndSelector extends dijit.tree._dndContainer {
            constructor();
            /**
             * The currently hovered TreeNode.  Not set to anything for keyboard operation.  (TODO: change?)
             * 
             */
            "current": Object;
            /**
             * (id to DomNode) map for every TreeNode that's currently selected.
             * The DOMNode is the TreeNode.rowNode.
             * 
             */
            "selection": Object;
            /**
             * Allows selection of only one element, if true.
             * Tree hasn't been tested in singular=true mode, unclear if it works.
             * 
             */
            "singular": boolean;
            /**
             * add node to current selection
             * 
             * @param node node to add             
             * @param isAnchor               OptionalWhether the node should become anchor.             
             */
            addTreeNode(node: HTMLElement, isAnchor: boolean): HTMLElement;
            /**
             * Prepares the object to be garbage-collected
             * 
             */
            destroy(): void;
            /**
             * Iterates over selected items;
             * see dojo/dnd/Container.forInItems() for details
             * 
             * @param f             
             * @param o               Optional            
             */
            forInSelectedItems(f: Function, o: Object): void;
            /**
             * Returns the dojo/dnd/Container._Item (representing a dragged node) by it's key (id).
             * Called by dojo/dnd/Source.checkAcceptance().
             * 
             * @param key             
             */
            getItem(key: String): Object;
            /**
             * Returns a list of selected node(s).
             * Used by dndSource on the start of a drag.
             * 
             */
            getSelectedTreeNodes(): any[];
            /**
             * return true if node is currently selected
             * 
             * @param node the node to check whether it's in the current selection             
             */
            isTreeNodeSelected(node: HTMLElement): any;
            /**
             * remove node and it's descendants from current selection
             * 
             * @param node node to remove             
             */
            removeTreeNode(node: HTMLElement): HTMLElement;
            /**
             * set the list of selected nodes to be exactly newSelection. All changes to the
             * selection should be passed through this function, which ensures that derived
             * attributes are kept up to date. Anchor will be deleted if it has been removed
             * from the selection, but no new anchor will be added by this function.
             * 
             * @param newSelection list of tree nodes to make selected             
             */
            setSelection(newSelection: HTMLElement[]): void;
            /**
             * Add or remove the given node from selection, responding
             * to a user action such as a click or keypress.
             * 
             * @param node             
             * @param multi Indicates whether this is meant to be a multi-select action (e.g. ctrl-click)             
             * @param range Indicates whether this is meant to be a ranged action (e.g. shift-click)             
             */
            userSelect(node: any, multi: boolean, range: boolean): void;
            /**
             * Event processor for onmousedown/ontouchstart/onkeydown corresponding to a click event
             * 
             * @param e onmousedown/ontouchstart/onkeydown event             
             */
            onClickPress(e: Event): void;
            /**
             * Event processor for onmouseup/ontouchend/onkeyup corresponding to a click event
             * 
             * @param e onmouseup/ontouchend/onkeyup event             
             */
            onClickRelease(e: Event): void;
            /**
             * Event processor for onmousedown/ontouchstart
             * 
             */
            onMouseDown(): void;
            /**
             * event processor for onmousemove/ontouchmove
             * 
             * @param e onmouseup/ontouchend event             
             */
            onMouseMove(e: Event): void;
            /**
             * Called when mouse is moved away from a TreeNode
             * 
             * @param widget             
             * @param evt             
             */
            onMouseOut(widget: dijit.Tree._TreeNode, evt: Event): void;
            /**
             * Called when mouse is moved over a TreeNode
             * 
             * @param widget             
             * @param evt             
             */
            onMouseOver(widget: dijit.Tree._TreeNode, evt: Event): void;
            /**
             * Event processor for onmouseup/ontouchend
             * 
             */
            onMouseUp(): void;
            /**
             * This function is called once, when mouse is out of our container
             * 
             */
            onOutEvent(): void;
            /**
             * This function is called once, when mouse is over our container
             * 
             */
            onOverEvent(): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/tree/dndSource.html
         *
         * Handles drag and drop operations (as a source or a target) for dijit.Tree
         * 
         * @param tree     
         * @param params     
         */
        class dndSource extends dijit.tree._dndSelector {
            constructor(tree: dijit.Tree, params: dijit.tree.dndSource);
            /**
             * List of accepted types (text strings) for the Tree; defaults to
             * ["text"]
             * 
             */
            "accept": Object;
            /**
             * Distance from upper/lower edge of node to allow drop to reorder nodes
             * 
             */
            "betweenThreshold": number;
            /**
             * The currently hovered TreeNode.  Not set to anything for keyboard operation.  (TODO: change?)
             * 
             */
            "current": Object;
            /**
             * The move delay in pixels before detecting a drag; 5 by default
             * 
             */
            "dragThreshold": number;
            /**
             * 
             */
            "generateText": boolean;
            /**
             * Can be used as a DnD source.
             * 
             */
            "isSource": boolean;
            /**
             * (id to DomNode) map for every TreeNode that's currently selected.
             * The DOMNode is the TreeNode.rowNode.
             * 
             */
            "selection": Object;
            /**
             * Allows selection of only one element, if true.
             * Tree hasn't been tested in singular=true mode, unclear if it works.
             * 
             */
            "singular": boolean;
            /**
             * add node to current selection
             * 
             * @param node node to add             
             * @param isAnchor               OptionalWhether the node should become anchor.             
             */
            addTreeNode(node: HTMLElement, isAnchor: boolean): HTMLElement;
            /**
             * Checks if the target can accept nodes from this source
             * 
             * @param source The source which provides items             
             * @param nodes Array of DOM nodes corresponding to nodes being dropped, dijitTreeRow nodes ifsource is a dijit/Tree.             
             */
            checkAcceptance(source: dijit.tree.dndSource, nodes: HTMLElement[]): boolean;
            /**
             * Stub function to be overridden if one wants to check for the ability to drop at the node/item level
             * In the base case, this is called to check if target can become a child of source.
             * When betweenThreshold is set, position="before" or "after" means that we
             * are asking if the source node can be dropped before/after the target node.
             * 
             * @param target The dijitTreeRoot DOM node inside of the TreeNode that we are dropping on toUse dijit.getEnclosingWidget(target) to get the TreeNode.             
             * @param source The (set of) nodes we are dropping             
             * @param position "over", "before", or "after"             
             */
            checkItemAcceptance(target: HTMLElement, source: dijit.tree.dndSource, position: String): boolean;
            /**
             * Returns true, if we need to copy items, false to move.
             * It is separated to be overwritten dynamically, if needed.
             * 
             * @param keyPressed The "copy" control key was pressed             
             */
            copyState(keyPressed: boolean): any;
            /**
             * Prepares the object to be garbage-collected.
             * 
             */
            destroy(): void;
            /**
             * Iterates over selected items;
             * see dojo/dnd/Container.forInItems() for details
             * 
             * @param f             
             * @param o               Optional            
             */
            forInSelectedItems(f: Function, o: Object): void;
            /**
             * Returns the dojo/dnd/Container._Item (representing a dragged node) by it's key (id).
             * Called by dojo/dnd/Source.checkAcceptance().
             * 
             * @param key             
             */
            getItem(key: String): Object;
            /**
             * Returns a list of selected node(s).
             * Used by dndSource on the start of a drag.
             * 
             */
            getSelectedTreeNodes(): any[];
            /**
             * return true if node is currently selected
             * 
             * @param node the node to check whether it's in the current selection             
             */
            isTreeNodeSelected(node: HTMLElement): any;
            /**
             * Returns objects passed to Tree.model.newItem() based on DnD nodes
             * dropped onto the tree.   Developer must override this method to enable
             * dropping from external sources onto this Tree, unless the Tree.model's items
             * happen to look like {id: 123, name: "Apple" } with no other attributes.
             * For each node in nodes[], which came from source, create a hash of name/value
             * pairs to be passed to Tree.model.newItem().  Returns array of those hashes.
             * 
             * @param nodes             
             * @param target             
             * @param source             
             */
            itemCreator(nodes: HTMLElement[], target: HTMLElement, source: dojo.dnd.Source): any;
            /**
             * remove node and it's descendants from current selection
             * 
             * @param node node to remove             
             */
            removeTreeNode(node: HTMLElement): HTMLElement;
            /**
             * set the list of selected nodes to be exactly newSelection. All changes to the
             * selection should be passed through this function, which ensures that derived
             * attributes are kept up to date. Anchor will be deleted if it has been removed
             * from the selection, but no new anchor will be added by this function.
             * 
             * @param newSelection list of tree nodes to make selected             
             */
            setSelection(newSelection: HTMLElement[]): void;
            /**
             * Add or remove the given node from selection, responding
             * to a user action such as a click or keypress.
             * 
             * @param node             
             * @param multi Indicates whether this is meant to be a multi-select action (e.g. ctrl-click)             
             * @param range Indicates whether this is meant to be a ranged action (e.g. shift-click)             
             */
            userSelect(node: any, multi: boolean, range: boolean): void;
            /**
             * Event processor for onmousedown/ontouchstart/onkeydown corresponding to a click event
             * 
             * @param e onmousedown/ontouchstart/onkeydown event             
             */
            onClickPress(e: Event): void;
            /**
             * Event processor for onmouseup/ontouchend/onkeyup corresponding to a click event
             * 
             * @param e onmouseup/ontouchend/onkeyup event             
             */
            onClickRelease(e: Event): void;
            /**
             * Topic event processor for /dnd/drop, called to finish the DnD operation.
             * Updates data store items according to where node was dragged from and dropped
             * to.   The tree will then respond to those data store updates and redraw itself.
             * 
             * @param source The dijit/tree/dndSource / dojo/dnd/Source which is providing the items             
             * @param nodes The list of transferred items, dndTreeNode nodes if dragging from a Tree             
             * @param copy Copy items, if true, move items otherwise             
             */
            onDndDrop(source: Object, nodes: HTMLElement[], copy: boolean): void;
            /**
             * Called when mouse is moved over a TreeNode
             * 
             * @param widget             
             * @param evt             
             */
            onMouseOver(widget: dijit.Tree._TreeNode, evt: Event): void;
        }
        module dndSource {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dijit/tree/dndSource.__Item.html
             *
             * New item to be added to the Tree, like:
             * 
             */
            interface __Item {
                /**
                 * 
                 */
                id: Object;
                /**
                 * 
                 */
                name: string;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/tree/model.html
         *
         * Contract for any data provider object for the tree.
         * Tree passes in values to the constructor to specify the callbacks.
         * "item" is typically a dojo/data/Item but it's just a black box so
         * it could be anything.
         * 
         * This (like dojo/data/api/Read) is just documentation, and not meant to be used.
         * 
         */
        class model {
            constructor();
            /**
             * Destroys this object, releasing connections to the store
             * 
             */
            destroy(): void;
            /**
             * Calls onComplete() with array of child items of given parent item, all loaded.
             * Throws exception on error.
             * 
             * @param parentItem             
             * @param onComplete             
             */
            getChildren(parentItem: dojo.data.api.Item, onComplete: any): void;
            /**
             * Returns identity for an item
             * 
             * @param item             
             */
            getIdentity(item: any): void;
            /**
             * Get the label for an item
             * 
             * @param item             
             */
            getLabel(item: any): void;
            /**
             * Calls onItem with the root item for the tree, possibly a fabricated item.
             * Throws exception on error.
             * 
             * @param onItem             
             */
            getRoot(onItem: any): void;
            /**
             * Returns true if something is an item and came from this model instance.
             * Returns false if something is a literal, an item from another model instance,
             * or is any object other than an item.
             * 
             * @param something             
             */
            isItem(something: any): void;
            /**
             * Tells if an item has or may have children.  Implementing logic here
             * avoids showing +/- expando icon for nodes that we know don't have children.
             * (For efficiency reasons we may not want to check if an element actually
             * has children until user clicks the expando node)
             * 
             * @param item             
             */
            mayHaveChildren(item: dojo.data.api.Item): void;
            /**
             * Creates a new item.   See dojo/data/api/Write for details on args.
             * 
             * @param args             
             * @param parent             
             * @param insertIndex               OptionalAllows to insert the new item as the n'th child of parent.             
             * @param before               OptionalInsert the new item as the previous sibling of this item.  before must be a child of parent.             
             */
            newItem(args: dijit.tree.dndSource.__Item, parent: any, insertIndex: number, before: any): void;
            /**
             * Move or copy an item from one parent item to another.
             * Used in drag & drop.
             * If oldParentItem is specified and bCopy is false, childItem is removed from oldParentItem.
             * If newParentItem is specified, childItem is attached to newParentItem.
             * 
             * @param childItem             
             * @param oldParentItem             
             * @param newParentItem             
             * @param bCopy             
             * @param insertIndex               OptionalAllows to insert the new item as the n'th child of parent.             
             * @param before               OptionalInsert the new item as the previous sibling of this item.  before must be a child of parent.             
             */
            pasteItem(childItem: any, oldParentItem: any, newParentItem: any, bCopy: boolean, insertIndex: number, before: any): void;
            /**
             * Callback whenever an item has changed, so that Tree
             * can update the label, icon, etc.   Note that changes
             * to an item's children or parent(s) will trigger an
             * onChildrenChange() so you can ignore those changes here.
             * 
             * @param item             
             */
            onChange(item: dojo.data.api.Item): void;
            /**
             * Callback to do notifications about new, updated, or deleted items.
             * 
             * @param parent             
             * @param newChildrenList             
             */
            onChildrenChange(parent: dojo.data.api.Item, newChildrenList: dojo.data.api.Item[]): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/tree/ForestStoreModel.html
         *
         * Interface between a dijit.Tree and a dojo.data store that doesn't have a root item,
         * a.k.a. a store that has multiple "top level" items.
         * Use this class to wrap a dojo.data store, making all the items matching the specified query
         * appear as children of a fabricated "root item".  If no query is specified then all the
         * items returned by fetch() on the underlying store become children of the root item.
         * This class allows dijit.Tree to assume a single root item, even if the store doesn't have one.
         * 
         * When using this class the developer must override a number of methods according to their app and
         * data, including:
         * 
         * onNewRootItem
         * onAddToRoot
         * onLeaveRoot
         * onNewItem
         * onSetItem
         * 
         * @param params     
         */
        class ForestStoreModel extends dijit.tree.TreeStoreModel {
            constructor(params: any);
            /**
             * One or more attribute names (attributes in the dojo.data item) that specify that item's children
             * 
             */
            "childrenAttrs": Object;
            /**
             * Setting this to true will cause the TreeStoreModel to defer calling loadItem on nodes
             * until they are expanded. This allows for lazying loading where only one
             * loadItem (and generally one network call, consequently) per expansion
             * (rather than one for each child).
             * This relies on partial loading of the children items; each children item of a
             * fully loaded item should contain the label and info about having children.
             * 
             */
            "deferItemLoadingUntilExpand": boolean;
            /**
             * If specified, get label for tree node from this attribute, rather
             * than by calling store.getLabel()
             * 
             */
            "labelAttr": string;
            /**
             * Name of attribute in the Object passed to newItem() that specifies the id.
             * 
             * If newItemIdAttr is set then it's used when newItem() is called to see if an
             * item with the same id already exists, and if so just links to the old item
             * (so that the old item ends up with two parents).
             * 
             * Setting this to null or "" will make every drop create a new item.
             * 
             */
            "newItemIdAttr": string;
            /**
             * Specifies the set of children of the root item.
             * 
             */
            "query": string;
            /**
             * Pointer to the root item (read only, not a parameter)
             * 
             */
            "root": Object;
            /**
             * ID of fabricated root item
             * 
             */
            "rootId": string;
            /**
             * Label of fabricated root item
             * 
             */
            "rootLabel": string;
            /**
             * Underlying store
             * 
             */
            "store": Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * 
             * @param keywordArgs             
             */
            fetchItemByIdentity(keywordArgs: Object): void;
            /**
             * Calls onComplete() with array of child items of given parent item, all loaded.
             * 
             * @param parentItem             
             * @param callback             
             * @param onError             
             */
            getChildren(parentItem: dojo.data.api.Item, callback: {(items:any[]):any;}, onError: Function): void;
            /**
             * 
             * @param item             
             */
            getIdentity(item: any): any;
            /**
             * 
             * @param item             
             */
            getLabel(item: any): any;
            /**
             * Calls onItem with the root item for the tree, possibly a fabricated item.
             * Calls onError on error.
             * 
             * @param onItem             
             * @param onError             
             */
            getRoot(onItem: any, onError: any): void;
            /**
             * 
             * @param something             
             */
            isItem(something: any): boolean;
            /**
             * Tells if an item has or may have children.  Implementing logic here
             * avoids showing +/- expando icon for nodes that we know don't have children.
             * (For efficiency reasons we may not want to check if an element actually
             * has children until user clicks the expando node)
             * 
             * @param item             
             */
            mayHaveChildren(item: dojo.data.api.Item): boolean;
            /**
             * Creates a new item.   See dojo/data/api/Write for details on args.
             * Used in drag & drop when item from external source dropped onto tree.
             * 
             * @param args             
             * @param parent             
             * @param insertIndex               Optional            
             */
            newItem(args: dijit.tree.dndSource.__Item, parent: any, insertIndex: number): any;
            /**
             * Move or copy an item from one parent item to another.
             * Used in drag & drop
             * 
             * @param childItem             
             * @param oldParentItem             
             * @param newParentItem             
             * @param bCopy             
             * @param insertIndex               Optional            
             */
            pasteItem(childItem: any, oldParentItem: any, newParentItem: any, bCopy: boolean, insertIndex: number): void;
            /**
             * Called when item added to root of tree; user must override this method
             * to modify the item so that it matches the query for top level items
             * 
             * @param item             
             */
            onAddToRoot(item: any): void;
            /**
             * Callback whenever an item has changed, so that Tree
             * can update the label, icon, etc.   Note that changes
             * to an item's children or parent(s) will trigger an
             * onChildrenChange() so you can ignore those changes here.
             * 
             * @param item             
             */
            onChange(item: dojo.data.api.Item): void;
            /**
             * Callback to do notifications about new, updated, or deleted items.
             * 
             * @param parent             
             * @param newChildrenList             
             */
            onChildrenChange(parent: dojo.data.api.Item, newChildrenList: dojo.data.api.Item[]): void;
            /**
             * Callback when an item has been deleted.
             * Note that there will also be an onChildrenChange() callback for the parent
             * of this item.
             * 
             * @param item             
             */
            onDelete(item: dojo.data.api.Item): void;
            /**
             * Handler for delete notifications from underlying store
             * 
             * @param item             
             */
            onDeleteItem(item: Object): void;
            /**
             * Called when item removed from root of tree; user must override this method
             * to modify the item so it doesn't match the query for top level items
             * 
             * @param item             
             */
            onLeaveRoot(item: any): void;
            /**
             * Handler for when new items appear in the store.  Developers should override this
             * method to be more efficient based on their app/data.
             * Note that the default implementation requeries the top level items every time
             * a new item is created, since any new item could be a top level item (even in
             * addition to being a child of another item, since items can have multiple parents).
             * 
             * If developers can detect which items are possible top level items (based on the item and the
             * parentInfo parameters), they should override this method to only call _requeryTop() for top
             * level items.  Often all top level items have parentInfo==null, but
             * that will depend on which store you use and what your data is like.
             * 
             * @param item             
             * @param parentInfo             
             */
            onNewItem(item: dojo.data.api.Item, parentInfo: Object): void;
            /**
             * User can override this method to modify a new element that's being
             * added to the root of the tree, for example to add a flag like root=true
             * 
             * @param args             
             */
            onNewRootItem(args: dijit.tree.dndSource.__Item): void;
            /**
             * Updates the tree view according to changes to an item in the data store.
             * Developers should override this method to be more efficient based on their app/data.
             * Handles updates to an item's children by calling onChildrenChange(), and
             * other updates to an item by calling onChange().
             * 
             * Also, any change to any item re-executes the query for the tree's top-level items,
             * since this modified item may have started/stopped matching the query for top level items.
             * 
             * If possible, developers should override this function to only call _requeryTop() when
             * the change to the item has caused it to stop/start being a top level item in the tree.
             * 
             * @param item             
             * @param attribute             
             * @param oldValue             
             * @param newValue             
             */
            onSetItem(item: any, attribute: String, oldValue: Object, newValue: Object): void;
            /**
             * Updates the tree view according to changes to an item in the data store.
             * Developers should override this method to be more efficient based on their app/data.
             * Handles updates to an item's children by calling onChildrenChange(), and
             * other updates to an item by calling onChange().
             * 
             * Also, any change to any item re-executes the query for the tree's top-level items,
             * since this modified item may have started/stopped matching the query for top level items.
             * 
             * If possible, developers should override this function to only call _requeryTop() when
             * the change to the item has caused it to stop/start being a top level item in the tree.
             * 
             * @param item             
             * @param attribute             
             * @param oldValue             
             * @param newValue             
             */
            onSetItem(item: any, attribute: String, oldValue: any[], newValue: Object): void;
            /**
             * Updates the tree view according to changes to an item in the data store.
             * Developers should override this method to be more efficient based on their app/data.
             * Handles updates to an item's children by calling onChildrenChange(), and
             * other updates to an item by calling onChange().
             * 
             * Also, any change to any item re-executes the query for the tree's top-level items,
             * since this modified item may have started/stopped matching the query for top level items.
             * 
             * If possible, developers should override this function to only call _requeryTop() when
             * the change to the item has caused it to stop/start being a top level item in the tree.
             * 
             * @param item             
             * @param attribute             
             * @param oldValue             
             * @param newValue             
             */
            onSetItem(item: any, attribute: String, oldValue: Object, newValue: any[]): void;
            /**
             * Updates the tree view according to changes to an item in the data store.
             * Developers should override this method to be more efficient based on their app/data.
             * Handles updates to an item's children by calling onChildrenChange(), and
             * other updates to an item by calling onChange().
             * 
             * Also, any change to any item re-executes the query for the tree's top-level items,
             * since this modified item may have started/stopped matching the query for top level items.
             * 
             * If possible, developers should override this function to only call _requeryTop() when
             * the change to the item has caused it to stop/start being a top level item in the tree.
             * 
             * @param item             
             * @param attribute             
             * @param oldValue             
             * @param newValue             
             */
            onSetItem(item: any, attribute: String, oldValue: any[], newValue: any[]): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/tree/ObjectStoreModel.html
         *
         * Implements dijit/tree/model connecting dijit/Tree to a dojo/store/api/Store that implements
         * getChildren().
         * 
         * If getChildren() returns an array with an observe() method, then it will be leveraged to reflect
         * store updates to the tree.   So, this class will work best when:
         * 
         * 1. the store implements dojo/store/Observable
         * 2. getChildren() is implemented as a query to the server (i.e. it calls store.query())
         * Drag and Drop: To support drag and drop, besides implementing getChildren()
         * and dojo/store/Observable, the store must support the parent option to put().
         * And in order to have child elements ordered according to how the user dropped them,
         * put() must support the before option.
         * 
         * @param args     
         */
        class ObjectStoreModel {
            constructor(args: Object);
            /**
             * Get label for tree node from this attribute
             * 
             */
            "labelAttr": string;
            /**
             * Specifies how to interpret the labelAttr in the data store items.
             * Can be "html" or "text".
             * 
             */
            "labelType": string;
            /**
             * Specifies datastore query to return the root item for the tree.
             * Must only return a single item.   Alternately can just pass in pointer
             * to root item.
             * 
             */
            "query": Object;
            /**
             * Pointer to the root item from the dojo/store/api/Store (read only, not a parameter)
             * 
             */
            "root": Object;
            /**
             * Underlying store
             * 
             */
            "store": Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Calls onComplete() with array of child items of given parent item.
             * 
             * @param parentItem Item from the dojo/store             
             * @param onComplete             
             * @param onError             
             */
            getChildren(parentItem: Object, onComplete: {(items:any[]):any;}, onError: Function): void;
            /**
             * 
             * @param item             
             */
            getIdentity(item: any): any;
            /**
             * Get the label for an item
             * 
             * @param item             
             */
            getLabel(item: dojo.data.api.Item): any;
            /**
             * Calls onItem with the root item for the tree, possibly a fabricated item.
             * Calls onError on error.
             * 
             * @param onItem             
             * @param onError             
             */
            getRoot(onItem: any, onError: any): void;
            /**
             * 
             * @param something             
             */
            isItem(something: any): boolean;
            /**
             * Tells if an item has or might have children.  Implementing logic here
             * avoids showing +/- expando icon for nodes that we know won't have children.
             * (For efficiency reasons we may not want to check if an element actually
             * has children until user clicks the expando node).
             * 
             * Application code should override this method based on the data, for example
             * it could be return item.leaf == true;.
             * 
             * Note that mayHaveChildren() must return true for an item if it could possibly
             * have children in the future, due to drag-an-drop or some other data store update.
             * Also note that it may return true if it's just too expensive to check during tree
             * creation whether or not the item has children.
             * 
             * @param item Item from the dojo/store             
             */
            mayHaveChildren(item: Object): boolean;
            /**
             * Creates a new item.   See dojo/data/api/Write for details on args.
             * Used in drag & drop when item from external source dropped onto tree.
             * 
             * @param args             
             * @param parent             
             * @param insertIndex               Optional            
             * @param before             
             */
            newItem(args: dijit.tree.dndSource.__Item, parent: any, insertIndex: number, before: any): any;
            /**
             * Move or copy an item from one parent item to another.
             * Used in drag & drop
             * 
             * @param childItem             
             * @param oldParentItem             
             * @param newParentItem             
             * @param bCopy             
             * @param insertIndex               Optional            
             * @param before             
             */
            pasteItem(childItem: any, oldParentItem: any, newParentItem: any, bCopy: boolean, insertIndex: number, before: any): any;
            /**
             * Callback whenever an item has changed, so that Tree
             * can update the label, icon, etc.   Note that changes
             * to an item's children or parent(s) will trigger an
             * onChildrenChange() so you can ignore those changes here.
             * 
             * @param item             
             */
            onChange(item: dojo.data.api.Item): void;
            /**
             * Callback to do notifications about new, updated, or deleted items.
             * 
             * @param parent             
             * @param newChildrenList Items from the store             
             */
            onChildrenChange(parent: dojo.data.api.Item, newChildrenList: Object[]): void;
            /**
             * Callback when an item has been deleted.
             * Actually we have no way of knowing this with the new dojo.store API,
             * so this method is never called (but it's left here since Tree connects
             * to it).
             * 
             * @param item             
             */
            onDelete(item: dojo.data.api.Item): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/tree/TreeStoreModel.html
         *
         * Implements dijit/Tree/model connecting to a dojo.data store with a single
         * root item.  Any methods passed into the constructor will override
         * the ones defined here.
         * 
         * @param args     
         */
        class TreeStoreModel {
            constructor(args: Object);
            /**
             * One or more attribute names (attributes in the dojo.data item) that specify that item's children
             * 
             */
            "childrenAttrs": Object;
            /**
             * Setting this to true will cause the TreeStoreModel to defer calling loadItem on nodes
             * until they are expanded. This allows for lazying loading where only one
             * loadItem (and generally one network call, consequently) per expansion
             * (rather than one for each child).
             * This relies on partial loading of the children items; each children item of a
             * fully loaded item should contain the label and info about having children.
             * 
             */
            "deferItemLoadingUntilExpand": boolean;
            /**
             * If specified, get label for tree node from this attribute, rather
             * than by calling store.getLabel()
             * 
             */
            "labelAttr": string;
            /**
             * Name of attribute in the Object passed to newItem() that specifies the id.
             * 
             * If newItemIdAttr is set then it's used when newItem() is called to see if an
             * item with the same id already exists, and if so just links to the old item
             * (so that the old item ends up with two parents).
             * 
             * Setting this to null or "" will make every drop create a new item.
             * 
             */
            "newItemIdAttr": string;
            /**
             * Specifies datastore query to return the root item for the tree.
             * Must only return a single item.   Alternately can just pass in pointer
             * to root item.
             * 
             */
            "query": Object;
            /**
             * Pointer to the root item (read only, not a parameter)
             * 
             */
            "root": Object;
            /**
             * Underlying store
             * 
             */
            "store": Object;
            /**
             * 
             */
            destroy(): void;
            /**
             * Given the identity of an item, this method returns the item that has
             * that identity through the onItem callback.  Conforming implementations
             * should return null if there is no item with the given identity.
             * Implementations of fetchItemByIdentity() may sometimes return an item
             * from a local cache and may sometimes fetch an item from a remote server.
             * 
             * @param keywordArgs             
             */
            fetchItemByIdentity(keywordArgs: Object): void;
            /**
             * Calls onComplete() with array of child items of given parent item, all loaded.
             * 
             * @param parentItem             
             * @param onComplete             
             * @param onError             
             */
            getChildren(parentItem: dojo.data.api.Item, onComplete: {(items:any[]):any;}, onError: Function): void;
            /**
             * 
             * @param item             
             */
            getIdentity(item: any): any;
            /**
             * Get the label for an item
             * 
             * @param item             
             */
            getLabel(item: dojo.data.api.Item): any;
            /**
             * Calls onItem with the root item for the tree, possibly a fabricated item.
             * Calls onError on error.
             * 
             * @param onItem             
             * @param onError             
             */
            getRoot(onItem: any, onError: any): void;
            /**
             * 
             * @param something             
             */
            isItem(something: any): any;
            /**
             * Tells if an item has or may have children.  Implementing logic here
             * avoids showing +/- expando icon for nodes that we know don't have children.
             * (For efficiency reasons we may not want to check if an element actually
             * has children until user clicks the expando node)
             * 
             * @param item             
             */
            mayHaveChildren(item: dojo.data.api.Item): any;
            /**
             * Creates a new item.   See dojo/data/api/Write for details on args.
             * Used in drag & drop when item from external source dropped onto tree.
             * Developers will need to override this method if new items get added
             * to parents with multiple children attributes, in order to define which
             * children attribute points to the new item.
             * 
             * @param args             
             * @param parent             
             * @param insertIndex               Optional            
             */
            newItem(args: dijit.tree.dndSource.__Item, parent: dojo.data.api.Item, insertIndex: number): void;
            /**
             * Move or copy an item from one parent item to another.
             * Used in drag & drop
             * 
             * @param childItem             
             * @param oldParentItem             
             * @param newParentItem             
             * @param bCopy             
             * @param insertIndex               Optional            
             */
            pasteItem(childItem: any, oldParentItem: any, newParentItem: any, bCopy: boolean, insertIndex: number): void;
            /**
             * Callback whenever an item has changed, so that Tree
             * can update the label, icon, etc.   Note that changes
             * to an item's children or parent(s) will trigger an
             * onChildrenChange() so you can ignore those changes here.
             * 
             * @param item             
             */
            onChange(item: dojo.data.api.Item): void;
            /**
             * Callback to do notifications about new, updated, or deleted items.
             * 
             * @param parent             
             * @param newChildrenList             
             */
            onChildrenChange(parent: dojo.data.api.Item, newChildrenList: dojo.data.api.Item[]): void;
            /**
             * Callback when an item has been deleted.
             * Note that there will also be an onChildrenChange() callback for the parent
             * of this item.
             * 
             * @param item             
             */
            onDelete(item: dojo.data.api.Item): void;
            /**
             * Handler for delete notifications from underlying store
             * 
             * @param item             
             */
            onDeleteItem(item: Object): void;
            /**
             * Handler for when new items appear in the store, either from a drop operation
             * or some other way.   Updates the tree view (if necessary).
             * If the new item is a child of an existing item,
             * calls onChildrenChange() with the new list of children
             * for that existing item.
             * 
             * @param item             
             * @param parentInfo             
             */
            onNewItem(item: dojo.data.api.Item, parentInfo: Object): void;
            /**
             * Updates the tree view according to changes in the data store.
             * Handles updates to an item's children by calling onChildrenChange(), and
             * other updates to an item by calling onChange().
             * 
             * See onNewItem for more details on handling updates to an item's children.
             * 
             * @param item             
             * @param attribute             
             * @param oldValue             
             * @param newValue             
             */
            onSetItem(item: any, attribute: any, oldValue: Object, newValue: Object): void;
            /**
             * Updates the tree view according to changes in the data store.
             * Handles updates to an item's children by calling onChildrenChange(), and
             * other updates to an item by calling onChange().
             * 
             * See onNewItem for more details on handling updates to an item's children.
             * 
             * @param item             
             * @param attribute             
             * @param oldValue             
             * @param newValue             
             */
            onSetItem(item: any, attribute: any, oldValue: any[], newValue: Object): void;
            /**
             * Updates the tree view according to changes in the data store.
             * Handles updates to an item's children by calling onChildrenChange(), and
             * other updates to an item by calling onChange().
             * 
             * See onNewItem for more details on handling updates to an item's children.
             * 
             * @param item             
             * @param attribute             
             * @param oldValue             
             * @param newValue             
             */
            onSetItem(item: any, attribute: any, oldValue: Object, newValue: any[]): void;
            /**
             * Updates the tree view according to changes in the data store.
             * Handles updates to an item's children by calling onChildrenChange(), and
             * other updates to an item by calling onChange().
             * 
             * See onNewItem for more details on handling updates to an item's children.
             * 
             * @param item             
             * @param attribute             
             * @param oldValue             
             * @param newValue             
             */
            onSetItem(item: any, attribute: any, oldValue: any[], newValue: any[]): void;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base.html
     *
     * Includes all the modules in dijit/_base
     * 
     */
    interface _base {
    }
    module _base {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base/focus.html
         *
         * Deprecated module to monitor currently focused node and stack of currently focused widgets.
         * New code should access dijit/focus directly.
         * 
         */
        interface focus {
            /**
             * Retrieves a bookmark that can be used with moveToBookmark to return to the same range
             * 
             */
            getBookmark(): any;
            /**
             * Called as getFocus(), this returns an Object showing the current focus
             * and selected text.
             * 
             * Called as getFocus(widget), where widget is a (widget representing) a button
             * that was just pressed, it returns where focus was before that button
             * was pressed.   (Pressing the button may have either shifted focus to the button,
             * or removed focus altogether.)   In this case the selected text is not returned,
             * since it can't be accurately determined.
             * 
             * @param menu               OptionalThe button that was just pressed.  If focus has disappeared or movedto this button, returns the previous focus.  In this case the bookmarkinformation is already lost, and null is returned.             
             * @param openedForWindow               Optionaliframe in which menu was opened             
             */
            getFocus(menu: dijit._WidgetBase, openedForWindow: Window): any;
            /**
             * Returns true if there is no text selected
             * 
             */
            isCollapsed(): any;
            /**
             * Moves current selection to a bookmark
             * 
             * @param bookmark This should be a returned object from dijit.getBookmark()             
             */
            moveToBookmark(bookmark: Object): any;
            /**
             * Registers listeners on the specified iframe so that any click
             * or focus event on that iframe (or anything in it) is reported
             * as a focus/click event on the <iframe> itself.
             * Currently only used by editor.
             * 
             * @param iframe             
             */
            registerIframe(iframe: HTMLElement): any;
            /**
             * Registers listeners on the specified window (either the main
             * window or an iframe's window) to detect when the user has clicked somewhere
             * or focused somewhere.
             * Users should call registerIframe() instead of this method.
             * 
             * @param targetWindow               OptionalIf specified this is the window associated with the iframe,i.e. iframe.contentWindow.             
             * @param effectiveNode               OptionalIf specified, report any focus events inside targetWindow asan event on effectiveNode, rather than on evt.target.             
             */
            registerWin(targetWindow: Window, effectiveNode: HTMLElement): any;
            /**
             * Unregisters listeners on the specified iframe created by registerIframe.
             * After calling be sure to delete or null out the handle itself.
             * 
             * @param handle Handle returned by registerIframe()             
             */
            unregisterIframe(handle: Object): void;
            /**
             * Unregisters listeners on the specified window (either the main
             * window or an iframe's window) according to handle returned from registerWin().
             * After calling be sure to delete or null out the handle itself.
             * 
             * @param handle             
             */
            unregisterWin(handle: Object): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base/manager.html
         *
         * Deprecated.  Shim to methods on registry, plus a few other declarations.
         * New code should access dijit/registry directly when possible.
         * 
         */
        interface manager {
            /**
             * The default fx.animation speed (in ms) to use for all Dijit
             * transitional fx.animations, unless otherwise specified
             * on a per-instance basis. Defaults to 200, overrided by
             * djConfig.defaultDuration
             * 
             */
            defaultDuration: number;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base/popup.html
         *
         * Deprecated.   Old module for popups, new code should use dijit/popup directly.
         * 
         */
        interface popup {
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base/place.html
         *
         * Deprecated back compatibility module, new code should use dijit/place directly instead of using this module.
         * 
         */
        interface place {
            /**
             * Deprecated method, unneeded when using dijit/place directly.
             * Transforms the passed array of preferred positions into a format suitable for
             * passing as the aroundCorners argument to dijit/place.placeOnScreenAroundElement.
             * 
             * @param position This variable controls the position of the drop down.It's an array of strings with the following values:before: places drop down to the left of the target node/widget, or to the right inthe case of RTL scripts like Hebrew and Arabicafter: places drop down to the right of the target node/widget, or to the left inthe case of RTL scripts like Hebrew and Arabicabove: drop down goes above target nodebelow: drop down goes below target nodeThe list is positions is tried, in order, until a position is found where the drop down fitswithin the viewport.             
             * @param leftToRight Whether the popup will be displaying in leftToRight mode.             
             */
            getPopupAroundAlignment(position: String[], leftToRight: boolean): void;
            /**
             * Deprecated method to return the dimensions and scroll position of the viewable area of a browser window.
             * New code should use windowUtils.getBox()
             * 
             */
            getViewport(): void;
            /**
             * Positions node kitty-corner to the rectangle centered at (pos.x, pos.y) with width and height of
             * padding.x  2 and padding.y  2, or zero if padding not specified.  Picks first corner in corners[]
             * where node is fully visible, or the corner where it's most visible.
             * 
             * Node is assumed to be absolutely or relatively positioned.
             * 
             * @param node The node to position             
             * @param pos Object like {x: 10, y: 20}             
             * @param corners Array of Strings representing order to try corners of the node in, like ["TR", "BL"].Possible values are:"BL" - bottom left"BR" - bottom right"TL" - top left"TR" - top right             
             * @param padding               OptionalOptional param to set padding, to put some buffer around the element you want to position.Defaults to zero.             
             * @param layoutNode For things like tooltip, they are displayed differently (and have different dimensions)based on their orientation relative to the parent.  This adjusts the popup based on orientation.             
             */
            placeOnScreen(node: HTMLElement, pos: dijit.place.__Position, corners: String[], padding: dijit.place.__Position, layoutNode: any): any;
            /**
             * Like dijit.placeOnScreenAroundNode(), except it accepts an arbitrary object
             * for the "around" argument and finds a proper processor to place a node.
             * Deprecated, new code should use dijit/place.around() instead.
             * 
             * @param node             
             * @param aroundNode             
             * @param aroundCorners             
             * @param layoutNode             
             */
            placeOnScreenAroundElement(node: any, aroundNode: any, aroundCorners: any, layoutNode: any): void;
            /**
             * Position node adjacent or kitty-corner to aroundNode
             * such that it's fully visible in viewport.
             * Deprecated, new code should use dijit/place.around() instead.
             * 
             * @param node             
             * @param aroundNode             
             * @param aroundCorners             
             * @param layoutNode             
             */
            placeOnScreenAroundNode(node: any, aroundNode: any, aroundCorners: any, layoutNode: any): void;
            /**
             * Like dijit.placeOnScreenAroundNode(), except that the "around"
             * parameter is an arbitrary rectangle on the screen (x, y, width, height)
             * instead of a dom node.
             * Deprecated, new code should use dijit/place.around() instead.
             * 
             * @param node             
             * @param aroundRect             
             * @param aroundCorners             
             * @param layoutNode             
             */
            placeOnScreenAroundRectangle(node: any, aroundRect: any, aroundCorners: any, layoutNode: any): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base/scroll.html
         *
         * Back compatibility module, new code should use windowUtils directly instead of using this module.
         * 
         */
        interface scroll {
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base/wai.html
         *
         * Deprecated methods for setting/getting wai roles and states.
         * New code should call setAttribute()/getAttribute() directly.
         * 
         * Also loads hccss to apply dj_a11y class to root node if machine is in high-contrast mode.
         * 
         */
        interface wai {
            /**
             * Gets the role for an element (which should be a wai role).
             * 
             * @param elem             
             */
            getWaiRole(elem: HTMLElement): any;
            /**
             * Gets the value of a state on an element.
             * Checks for an attribute called "aria-"+state.
             * 
             * @param elem             
             * @param state             
             */
            getWaiState(elem: HTMLElement, state: String): any;
            /**
             * Determines if an element has a particular role.
             * 
             * @param elem             
             * @param role               Optional            
             */
            hasWaiRole(elem: HTMLElement, role: String): any;
            /**
             * Determines if an element has a given state.
             * Checks for an attribute called "aria-"+state.
             * 
             * @param elem             
             * @param state             
             */
            hasWaiState(elem: HTMLElement, state: String): any;
            /**
             * Removes the specified role from an element.
             * Removes role attribute if no specific role provided (for backwards compat.)
             * 
             * @param elem             
             * @param role             
             */
            removeWaiRole(elem: HTMLElement, role: String): void;
            /**
             * Removes a state from an element.
             * Sets an attribute called "aria-"+state.
             * 
             * @param elem             
             * @param state             
             */
            removeWaiState(elem: HTMLElement, state: String): void;
            /**
             * Sets the role on an element.
             * Replace existing role attribute with new role.
             * 
             * @param elem             
             * @param role             
             */
            setWaiRole(elem: HTMLElement, role: String): void;
            /**
             * Sets a state on an element.
             * Sets an attribute called "aria-"+state.
             * 
             * @param elem             
             * @param state             
             * @param value             
             */
            setWaiState(elem: HTMLElement, state: String, value: String): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base/typematic.html
         *
         * Deprecated, for back-compat, just loads top level module
         * 
         */
        interface typematic {
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base/window.html
         *
         * Back compatibility module, new code should use windowUtils directly instead of using this module.
         * 
         */
        interface window {
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/_base/sniff.html
         *
         * Deprecated, back compatibility module, new code should require dojo/uacss directly instead of this module.
         * 
         */
        interface sniff {
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_BidiMixin.html
     *
     * When has("dojo-bidi") is true, _WidgetBase will mixin this class.   It enables support for the textdir
     * property to control text direction independently from the GUI direction.
     * There's a special need for displaying BIDI text in rtl direction
     * in ltr GUI, sometimes needed auto support.
     * In creation of widget, if it's want to activate this class,
     * the widget should define the "textDir".
     * 
     */
    interface _BidiMixin {
        /**
         * Bi-directional support, the main variable which is responsible for the direction of the text.
         * The text direction can be different than the GUI direction by using this parameter in creation
         * of a widget.
         * 
         * Allowed values:
         * 
         * "ltr"
         * "rtl"
         * "auto" - contextual the direction of a text defined by first strong letter.
         * By default is as the page direction.
         * 
         */
        textDir: string;
        /**
         * Set element.dir according to this.textDir, assuming this.textDir has a value.
         * If textDir is ltr or rtl returns the value.
         * If it's auto, calls to another function that responsible
         * for checking the value, and defining the direction.
         * 
         * @param element The text element to be set. Should have dir property.             
         * @param text               OptionalIf specified, and this.textDir is "auto", for calculating the right transformationOtherwise text read from element.             
         */
        applyTextDir(element: HTMLElement, text: String): void;
        /**
         * Wraps by UCC (Unicode control characters) option's text according to this.textDir
         * There's a dir problem with some HTML elements. For some elements (e.g. <option>, <select>)
         * defining the dir in different direction then the GUI orientation, won't display correctly.
         * FF 3.6 will change the alignment of the text in option - this doesn't follow the bidi standards (static text
         * should be aligned following GUI direction). IE8 and Opera11.10 completely ignore dir setting for <option>.
         * Therefore the only solution is to use UCC (Unicode  control characters) to display the text in correct orientation.
         * This function saves the original text value for later restoration if needed, for example if the textDir will change etc.
         * 
         * @param option The element (<option>) we wrapping the text for.             
         * @param text The text to be wrapped.             
         */
        enforceTextDirWithUcc(option: any, text: any): String;
        /**
         * Gets the right direction of text.
         * If textDir is ltr or rtl returns the value.
         * If it's auto, calls to another function that responsible
         * for checking the value, and defining the direction.
         * 
         * @param text             
         */
        getTextDir(text: String): any;
        /**
         * Restores the text of origObj, if needed, after enforceTextDirWithUcc, e.g. set("textDir", textDir).
         * Sets the text of origObj to origObj.originalText, which is the original text, without the UCCs.
         * The function than removes the originalText from origObj!
         * 
         * @param origObj The element (<option>) to restore.             
         */
        restoreOriginalText(origObj: any): any;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/_Calendar.html
     *
     * Deprecated widget, used dijit/Calendar instead.   Will be removed in 2.0.
     * 
     */
    interface _Calendar {
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/a11yclick.html
     *
     * Custom press, release, and click synthetic events
     * which trigger on a left mouse click, touch, or space/enter keyup.
     * 
     */
    interface a11yclick {
        /**
         * Logical click operation for mouse, touch, or keyboard (space/enter key)
         * 
         * @param node             
         * @param listener             
         */
        click(node: any, listener: any): void;
        /**
         * Mouse cursor or a finger is dragged over the given node.
         * 
         * @param node             
         * @param listener             
         */
        move(node: any, listener: any): void;
        /**
         * Mousedown (left button), touchstart, or keydown (space or enter) corresponding to logical click operation.
         * 
         * @param node             
         * @param listener             
         */
        press(node: any, listener: any): void;
        /**
         * Mouseup (left button), touchend, or keyup (space or enter) corresponding to logical click operation.
         * 
         * @param node             
         * @param listener             
         */
        release(node: any, listener: any): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/a11y.html
     *
     * Accessibility utility functions (keyboard, tab stops, etc.)
     * 
     */
    interface a11y {
        /**
         * Returns effective tabIndex of an element, either a number, or undefined if element isn't focusable.
         * 
         * @param elem             
         */
        effectiveTabIndex(elem: HTMLElement): any;
        /**
         * Finds the descendant of the specified root node
         * that is first in the tabbing order
         * 
         * @param root             
         * @param doc               Optional            
         */
        getFirstInTabbingOrder(root: String, doc: HTMLDocument): any;
        /**
         * Finds the descendant of the specified root node
         * that is first in the tabbing order
         * 
         * @param root             
         * @param doc               Optional            
         */
        getFirstInTabbingOrder(root: HTMLElement, doc: HTMLDocument): any;
        /**
         * Finds the descendant of the specified root node
         * that is last in the tabbing order
         * 
         * @param root             
         * @param doc               Optional            
         */
        getLastInTabbingOrder(root: String, doc: HTMLDocument): any;
        /**
         * Finds the descendant of the specified root node
         * that is last in the tabbing order
         * 
         * @param root             
         * @param doc               Optional            
         */
        getLastInTabbingOrder(root: HTMLElement, doc: HTMLDocument): any;
        /**
         * Tests if element is tab-navigable even without an explicit tabIndex setting
         * 
         * @param elem             
         */
        hasDefaultTabStop(elem: HTMLElement): any;
        /**
         * Tests if an element is focusable by tabbing to it, or clicking it with the mouse.
         * 
         * @param elem             
         */
        isFocusable(elem: HTMLElement): boolean;
        /**
         * Tests if an element is tab-navigable
         * 
         * @param elem             
         */
        isTabNavigable(elem: HTMLElement): boolean;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/dijit.html
     *
     * A roll-up for common dijit methods
     * All the stuff in _base (these are the function that are guaranteed available without an explicit dojo.require)
     * And some other stuff that we tend to pull in all the time anyway
     * 
     */
    interface dijit {
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/dijit-all.html
     *
     * A rollup that includes every dijit. You probably don't need this.
     * 
     */
    interface dijit_all {
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/main.html
     *
     * The dijit package main module.
     * Deprecated.   Users should access individual modules (ex: dijit/registry) directly.
     * 
     */
    interface main {
        /**
         * The default fx.animation speed (in ms) to use for all Dijit
         * transitional fx.animations, unless otherwise specified
         * on a per-instance basis. Defaults to 200, overrided by
         * djConfig.defaultDuration
         * 
         */
        defaultDuration: number;
        /**
         * Code to place a DOMNode relative to another DOMNode.
         * Load using require(["dijit/place"], function(place){ ... }).
         * 
         */
        place: Object;
        /**
         * 
         */
        popup: Object;
        /**
         * Registry of existing widget on page, plus some utility methods.
         * 
         */
        registry: Object;
        /**
         * These functions are used to repetitively call a user specified callback
         * method when a specific key or mouse click over a specific DOM node is
         * held down for a specific amount of time.
         * Only 1 such event is allowed to occur on the browser page at 1 time.
         * 
         */
        typematic: Object;
        /**
         * For IE/FF z-index shenanigans. id attribute is required.
         * new dijit.BackgroundIframe(node).
         * 
         * Makes a background iframe as a child of node, that fills
         * area (and position) of node
         * 
         * @param node             
         */
        BackgroundIframe(node: HTMLElement): void;
        /**
         * Returns effective tabIndex of an element, either a number, or undefined if element isn't focusable.
         * 
         * @param elem             
         */
        effectiveTabIndex(elem: HTMLElement): any;
        /**
         * 
         * @param node             
         */
        focus(node: any): void;
        /**
         * Retrieves a bookmark that can be used with moveToBookmark to return to the same range
         * 
         */
        getBookmark(): any;
        /**
         * 
         * @param doc             
         */
        getDocumentWindow(doc: any): void;
        /**
         * Finds the descendant of the specified root node
         * that is first in the tabbing order
         * 
         * @param root             
         * @param doc               Optional            
         */
        getFirstInTabbingOrder(root: String, doc: HTMLDocument): any;
        /**
         * Finds the descendant of the specified root node
         * that is first in the tabbing order
         * 
         * @param root             
         * @param doc               Optional            
         */
        getFirstInTabbingOrder(root: HTMLElement, doc: HTMLDocument): any;
        /**
         * Called as getFocus(), this returns an Object showing the current focus
         * and selected text.
         * 
         * Called as getFocus(widget), where widget is a (widget representing) a button
         * that was just pressed, it returns where focus was before that button
         * was pressed.   (Pressing the button may have either shifted focus to the button,
         * or removed focus altogether.)   In this case the selected text is not returned,
         * since it can't be accurately determined.
         * 
         * @param menu               OptionalThe button that was just pressed.  If focus has disappeared or movedto this button, returns the previous focus.  In this case the bookmarkinformation is already lost, and null is returned.             
         * @param openedForWindow               Optionaliframe in which menu was opened             
         */
        getFocus(menu: dijit._WidgetBase, openedForWindow: Window): any;
        /**
         * Finds the descendant of the specified root node
         * that is last in the tabbing order
         * 
         * @param root             
         * @param doc               Optional            
         */
        getLastInTabbingOrder(root: String, doc: HTMLDocument): any;
        /**
         * Finds the descendant of the specified root node
         * that is last in the tabbing order
         * 
         * @param root             
         * @param doc               Optional            
         */
        getLastInTabbingOrder(root: HTMLElement, doc: HTMLDocument): any;
        /**
         * Deprecated method, unneeded when using dijit/place directly.
         * Transforms the passed array of preferred positions into a format suitable for
         * passing as the aroundCorners argument to dijit/place.placeOnScreenAroundElement.
         * 
         * @param position This variable controls the position of the drop down.It's an array of strings with the following values:before: places drop down to the left of the target node/widget, or to the right inthe case of RTL scripts like Hebrew and Arabicafter: places drop down to the right of the target node/widget, or to the left inthe case of RTL scripts like Hebrew and Arabicabove: drop down goes above target nodebelow: drop down goes below target nodeThe list is positions is tried, in order, until a position is found where the drop down fitswithin the viewport.             
         * @param leftToRight Whether the popup will be displaying in leftToRight mode.             
         */
        getPopupAroundAlignment(position: String[], leftToRight: boolean): void;
        /**
         * Deprecated method to return the dimensions and scroll position of the viewable area of a browser window.
         * New code should use windowUtils.getBox()
         * 
         */
        getViewport(): void;
        /**
         * Gets the role for an element (which should be a wai role).
         * 
         * @param elem             
         */
        getWaiRole(elem: HTMLElement): any;
        /**
         * Gets the value of a state on an element.
         * Checks for an attribute called "aria-"+state.
         * 
         * @param elem             
         * @param state             
         */
        getWaiState(elem: HTMLElement, state: String): any;
        /**
         * Tests if element is tab-navigable even without an explicit tabIndex setting
         * 
         * @param elem             
         */
        hasDefaultTabStop(elem: HTMLElement): any;
        /**
         * Determines if an element has a particular role.
         * 
         * @param elem             
         * @param role               Optional            
         */
        hasWaiRole(elem: HTMLElement, role: String): any;
        /**
         * Determines if an element has a given state.
         * Checks for an attribute called "aria-"+state.
         * 
         * @param elem             
         * @param state             
         */
        hasWaiState(elem: HTMLElement, state: String): any;
        /**
         * Static method to hide the tooltip displayed via showTooltip()
         * 
         * @param aroundNode             
         */
        hideTooltip(aroundNode: any): any;
        /**
         * Returns true if there is no text selected
         * 
         */
        isCollapsed(): any;
        /**
         * Tests if an element is focusable by tabbing to it, or clicking it with the mouse.
         * 
         * @param elem             
         */
        isFocusable(elem: HTMLElement): boolean;
        /**
         * Tests if an element is tab-navigable
         * 
         * @param elem             
         */
        isTabNavigable(elem: HTMLElement): boolean;
        /**
         * Moves current selection to a bookmark
         * 
         * @param bookmark This should be a returned object from dijit.getBookmark()             
         */
        moveToBookmark(bookmark: Object): any;
        /**
         * Positions node kitty-corner to the rectangle centered at (pos.x, pos.y) with width and height of
         * padding.x  2 and padding.y  2, or zero if padding not specified.  Picks first corner in corners[]
         * where node is fully visible, or the corner where it's most visible.
         * 
         * Node is assumed to be absolutely or relatively positioned.
         * 
         * @param node The node to position             
         * @param pos Object like {x: 10, y: 20}             
         * @param corners Array of Strings representing order to try corners of the node in, like ["TR", "BL"].Possible values are:"BL" - bottom left"BR" - bottom right"TL" - top left"TR" - top right             
         * @param padding               OptionalOptional param to set padding, to put some buffer around the element you want to position.Defaults to zero.             
         * @param layoutNode For things like tooltip, they are displayed differently (and have different dimensions)based on their orientation relative to the parent.  This adjusts the popup based on orientation.             
         */
        placeOnScreen(node: HTMLElement, pos: dijit.place.__Position, corners: String[], padding: dijit.place.__Position, layoutNode: any): any;
        /**
         * Like dijit.placeOnScreenAroundNode(), except it accepts an arbitrary object
         * for the "around" argument and finds a proper processor to place a node.
         * Deprecated, new code should use dijit/place.around() instead.
         * 
         * @param node             
         * @param aroundNode             
         * @param aroundCorners             
         * @param layoutNode             
         */
        placeOnScreenAroundElement(node: any, aroundNode: any, aroundCorners: any, layoutNode: any): void;
        /**
         * Position node adjacent or kitty-corner to aroundNode
         * such that it's fully visible in viewport.
         * Deprecated, new code should use dijit/place.around() instead.
         * 
         * @param node             
         * @param aroundNode             
         * @param aroundCorners             
         * @param layoutNode             
         */
        placeOnScreenAroundNode(node: any, aroundNode: any, aroundCorners: any, layoutNode: any): void;
        /**
         * Like dijit.placeOnScreenAroundNode(), except that the "around"
         * parameter is an arbitrary rectangle on the screen (x, y, width, height)
         * instead of a dom node.
         * Deprecated, new code should use dijit/place.around() instead.
         * 
         * @param node             
         * @param aroundRect             
         * @param aroundCorners             
         * @param layoutNode             
         */
        placeOnScreenAroundRectangle(node: any, aroundRect: any, aroundCorners: any, layoutNode: any): void;
        /**
         * Registers listeners on the specified iframe so that any click
         * or focus event on that iframe (or anything in it) is reported
         * as a focus/click event on the <iframe> itself.
         * Currently only used by editor.
         * 
         * @param iframe             
         */
        registerIframe(iframe: HTMLElement): any;
        /**
         * Registers listeners on the specified window (either the main
         * window or an iframe's window) to detect when the user has clicked somewhere
         * or focused somewhere.
         * Users should call registerIframe() instead of this method.
         * 
         * @param targetWindow               OptionalIf specified this is the window associated with the iframe,i.e. iframe.contentWindow.             
         * @param effectiveNode               OptionalIf specified, report any focus events inside targetWindow asan event on effectiveNode, rather than on evt.target.             
         */
        registerWin(targetWindow: Window, effectiveNode: HTMLElement): any;
        /**
         * Removes the specified role from an element.
         * Removes role attribute if no specific role provided (for backwards compat.)
         * 
         * @param elem             
         * @param role             
         */
        removeWaiRole(elem: HTMLElement, role: String): void;
        /**
         * Removes a state from an element.
         * Sets an attribute called "aria-"+state.
         * 
         * @param elem             
         * @param state             
         */
        removeWaiState(elem: HTMLElement, state: String): void;
        /**
         * Scroll the passed node into view, if it is not already.
         * Deprecated, use windowUtils.scrollIntoView instead.
         * 
         * @param node             
         * @param pos               Optional            
         */
        scrollIntoView(node: HTMLElement, pos: Object): void;
        /**
         * Select text in the input element argument, from start (default 0), to stop (default end).
         * 
         * @param element             
         * @param start               Optional            
         * @param stop               Optional            
         */
        selectInputText(element: HTMLElement, start: number, stop: number): void;
        /**
         * Sets the role on an element.
         * Replace existing role attribute with new role.
         * 
         * @param elem             
         * @param role             
         */
        setWaiRole(elem: HTMLElement, role: String): void;
        /**
         * Sets a state on an element.
         * Sets an attribute called "aria-"+state.
         * 
         * @param elem             
         * @param state             
         * @param value             
         */
        setWaiState(elem: HTMLElement, state: String, value: String): void;
        /**
         * Static method to display tooltip w/specified contents in specified position.
         * See description of dijit/Tooltip.defaultPosition for details on position parameter.
         * If position is not specified then dijit/Tooltip.defaultPosition is used.
         * 
         * @param innerHTML Contents of the tooltip             
         * @param aroundNode Specifies that tooltip should be next to this node / area             
         * @param position               OptionalList of positions to try to position tooltip (ex: ["right", "above"])             
         * @param rtl               OptionalCorresponds to WidgetBase.dir attribute, where false means "ltr" and truemeans "rtl"; specifies GUI direction, not text direction.             
         * @param textDir               OptionalCorresponds to WidgetBase.textdir attribute; specifies direction of text.             
         */
        showTooltip(innerHTML: String, aroundNode: Object, position: String[], rtl: boolean, textDir: String): any;
        /**
         * Unregisters listeners on the specified iframe created by registerIframe.
         * After calling be sure to delete or null out the handle itself.
         * 
         * @param handle Handle returned by registerIframe()             
         */
        unregisterIframe(handle: Object): void;
        /**
         * Unregisters listeners on the specified window (either the main
         * window or an iframe's window) according to handle returned from registerWin().
         * After calling be sure to delete or null out the handle itself.
         * 
         * @param handle             
         */
        unregisterWin(handle: Object): void;
    }
    module main {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/main._Calendar.html
         *
         * A simple GUI for choosing a date in the context of a monthly calendar.
         * See CalendarLite for general description.   Calendar extends CalendarLite, adding:
         * 
         * month drop down list
         * keyboard navigation
         * CSS classes for hover/mousepress on date, month, and year nodes
         * support of deprecated methods (will be removed in 2.0)
         * 
         * @param params Hash of initialization parameters for widget, including scalar values (like title, duration etc.)and functions, typically callbacks like onClick.The hash can contain any of the widget's properties, excluding read-only properties.     
         * @param srcNodeRef       OptionalIf a srcNodeRef (DOM node) is specified, replace srcNodeRef with my generated DOM tree     
         */
        class _Calendar extends dijit.CalendarLite implements dijit._Widget, dijit._CssStateMixin {
            constructor(params?: Object, srcNodeRef?: HTMLElement);
            /**
             * Custom press, release, and click synthetic events
             * which trigger on a left mouse click, touch, or space/enter keyup.
             * 
             */
            "a11yclick": Object;
            /**
             * True if mouse was pressed while over this widget, and hasn't been released yet
             * 
             */
            "active": boolean;
            set(property:"active", value: boolean): void;
            get(property:"active"): boolean;
            watch(property:"active", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Object to which attach points and events will be scoped.  Defaults
             * to 'this'.
             * 
             */
            "attachScope": Object;
            set(property:"attachScope", value: Object): void;
            get(property:"attachScope"): Object;
            watch(property:"attachScope", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
             * for each XXX attribute to be mapped to the DOM.
             * 
             * attributeMap sets up a "binding" between attributes (aka properties)
             * of the widget and the widget's DOM.
             * Changes to widget attributes listed in attributeMap will be
             * reflected into the DOM.
             * 
             * For example, calling set('title', 'hello')
             * on a TitlePane will automatically cause the TitlePane's DOM to update
             * with the new title.
             * 
             * attributeMap is a hash where the key is an attribute of the widget,
             * and the value reflects a binding to a:
             * 
             * DOM node attribute
             *   focus: {node: "focusNode", type: "attribute"}
             * Maps this.focus to this.focusNode.focus
             * 
             * DOM node innerHTML
             *   title: { node: "titleNode", type: "innerHTML" }
             * Maps this.title to this.titleNode.innerHTML
             * 
             * DOM node innerText
             *   title: { node: "titleNode", type: "innerText" }
             * Maps this.title to this.titleNode.innerText
             * 
             * DOM node CSS class
             *   myClass: { node: "domNode", type: "class" }
             * Maps this.myClass to this.domNode.className
             * 
             * If the value is an array, then each element in the array matches one of the
             * formats of the above list.
             * 
             * There are also some shorthands for backwards compatibility:
             * 
             * string --> { node: string, type: "attribute" }, for example:
             * "focusNode" ---> { node: "focusNode", type: "attribute" }
             * "" --> { node: "domNode", type: "attribute" }
             * 
             */
            "attributeMap": Object;
            set(property:"attributeMap", value: Object): void;
            get(property:"attributeMap"): Object;
            watch(property:"attributeMap", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "baseClass": string;
            set(property:"baseClass", value: string): void;
            get(property:"baseClass"): string;
            watch(property:"baseClass", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "class": string;
            set(property:"class", value: string): void;
            get(property:"class"): string;
            watch(property:"class", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Designates where children of the source DOM node will be placed.
             * "Children" in this case refers to both DOM nodes and widgets.
             * For example, for myWidget:
             * 
             * <div data-dojo-type=myWidget>
             *     <b> here's a plain DOM node
             *     <span data-dojo-type=subWidget>and a widget</span>
             *     <i> and another plain DOM node </i>
             * </div>
             * containerNode would point to:
             * 
             * <b> here's a plain DOM node
             * <span data-dojo-type=subWidget>and a widget</span>
             * <i> and another plain DOM node </i>
             * In templated widgets, "containerNode" is set via a
             * data-dojo-attach-point assignment.
             * 
             * containerNode must be defined for any widget that accepts innerHTML
             * (like ContentPane or BorderContainer or even Button), and conversely
             * is null for widgets that don't, like TextBox.
             * 
             */
            "containerNode": HTMLElement;
            set(property:"containerNode", value: HTMLElement): void;
            get(property:"containerNode"): HTMLElement;
            watch(property:"containerNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "cssStateNodes": Object;
            set(property:"cssStateNodes", value: Object): void;
            get(property:"cssStateNodes"): Object;
            watch(property:"cssStateNodes", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Date object containing the currently focused date, or the date which would be focused
             * if the calendar itself was focused.   Also indicates which year and month to display,
             * i.e. the current "page" the calendar is on.
             * 
             */
            "currentFocus": Date;
            set(property:"currentFocus", value: Date): void;
            get(property:"currentFocus"): Date;
            watch(property:"currentFocus", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
            /**
             * JavaScript namespace to find calendar routines.  If unspecified, uses Gregorian calendar routines
             * at dojo/date and dojo/date/locale.
             * 
             */
            "datePackage": string;
            set(property:"datePackage", value: string): void;
            get(property:"datePackage"): string;
            watch(property:"datePackage", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "dateTemplateString": string;
            set(property:"dateTemplateString", value: string): void;
            get(property:"dateTemplateString"): string;
            watch(property:"dateTemplateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * How to represent the days of the week in the calendar header. See locale
             * 
             */
            "dayWidth": string;
            set(property:"dayWidth", value: string): void;
            get(property:"dayWidth"): string;
            watch(property:"dayWidth", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Bi-directional support, as defined by the HTML DIR
             * attribute. Either left-to-right "ltr" or right-to-left "rtl".  If undefined, widgets renders in page's
             * default direction.
             * 
             */
            "dir": string;
            set(property:"dir", value: string): void;
            get(property:"dir"): string;
            watch(property:"dir", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Defines a type of widget.
             * 
             */
            "dndType": string;
            set(property:"dndType", value: string): void;
            get(property:"dndType"): string;
            watch(property:"dndType", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This is our visible representation of the widget! Other DOM
             * Nodes may by assigned to other properties, usually through the
             * template system's data-dojo-attach-point syntax, but the domNode
             * property is the canonical "top level" node in widget UI.
             * 
             */
            "domNode": HTMLElement;
            set(property:"domNode", value: HTMLElement): void;
            get(property:"domNode"): HTMLElement;
            watch(property:"domNode", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * 
             */
            "dowTemplateString": string;
            set(property:"dowTemplateString", value: string): void;
            get(property:"dowTemplateString"): string;
            watch(property:"dowTemplateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This widget or a widget it contains has focus, or is "active" because
             * it was recently clicked.
             * 
             */
            "focused": boolean;
            set(property:"focused", value: boolean): void;
            get(property:"focused"): boolean;
            watch(property:"focused", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * True if cursor is over this widget
             * 
             */
            "hovering": boolean;
            set(property:"hovering", value: boolean): void;
            get(property:"hovering"): boolean;
            watch(property:"hovering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A unique, opaque ID string that can be assigned by users or by the
             * system. If the developer passes an ID which is known not to be
             * unique, the specified ID is ignored and the system-generated ID is
             * used instead.
             * 
             */
            "id": string;
            set(property:"id", value: string): void;
            get(property:"id"): string;
            watch(property:"id", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Rarely used.  Overrides the default Dojo locale used to render this widget,
             * as defined by the HTML LANG attribute.
             * Value must be among the list of locales specified during by the Dojo bootstrap,
             * formatted according to RFC 3066 (like en-us).
             * 
             */
            "lang": string;
            set(property:"lang", value: string): void;
            get(property:"lang"): string;
            watch(property: "lang", callback: { (property?: string, oldValue?: string, newValue?: string): void }): { unwatch(): void }
            /**
             * 
             */
            "observer": string;
            set(property:"observer", value: string): void;
            get(property:"observer"): string;
            watch(property:"observer", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The document this widget belongs to.  If not specified to constructor, will default to
             * srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
             * 
             */
            "ownerDocument": Object;
            set(property:"ownerDocument", value: Object): void;
            get(property:"ownerDocument"): Object;
            watch(property:"ownerDocument", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * 
             */
            "searchContainerNode": boolean;
            set(property:"searchContainerNode", value: boolean): void;
            get(property:"searchContainerNode"): boolean;
            watch(property:"searchContainerNode", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * A parameter needed by RadioGroupSlide only. An optional paramter to force
             * the ContentPane to slide in from a set direction. Defaults
             * to "random", or specify one of "top", "left", "right", "bottom"
             * to slideFrom top, left, right, or bottom.
             * 
             */
            "slideFrom": string;
            set(property:"slideFrom", value: string): void;
            get(property:"slideFrom"): string;
            watch(property:"slideFrom", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * pointer to original DOM node
             * 
             */
            "srcNodeRef": HTMLElement;
            set(property:"srcNodeRef", value: HTMLElement): void;
            get(property:"srcNodeRef"): HTMLElement;
            watch(property:"srcNodeRef", callback:{(property?:string, oldValue?:HTMLElement, newValue?: HTMLElement):void}) :{unwatch():void}
            /**
             * HTML style attributes as cssText string or name/value hash
             * 
             */
            "style": string;
            set(property:"style", value: string): void;
            get(property:"style"): string;
            watch(property:"style", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Order fields are traversed when user hits the tab key
             * 
             */
            "tabIndex": string;
            set(property:"tabIndex", value: string): void;
            get(property:"tabIndex"): string;
            watch(property:"tabIndex", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Path to template (HTML file) for this widget relative to dojo.baseUrl.
             * Deprecated: use templateString with require([... "dojo/text!..."], ...) instead
             * 
             */
            "templatePath": string;
            set(property:"templatePath", value: string): void;
            get(property:"templatePath"): string;
            watch(property:"templatePath", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * 
             */
            "templateString": string;
            set(property:"templateString", value: string): void;
            get(property:"templateString"): string;
            watch(property:"templateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * HTML title attribute.
             * 
             * For form widgets this specifies a tooltip to display when hovering over
             * the widget (just like the native HTML title attribute).
             * 
             * For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
             * etc., it's used to specify the tab label, accordion pane title, etc.  In this case it's
             * interpreted as HTML.
             * 
             */
            "title": string;
            set(property:"title", value: string): void;
            get(property:"title"): string;
            watch(property:"title", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
             * this specifies the tooltip to appear when the mouse is hovered over that text.
             * 
             */
            "tooltip": string;
            set(property:"tooltip", value: string): void;
            get(property:"tooltip"): string;
            watch(property:"tooltip", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The currently selected Date, initially set to invalid date to indicate no selection.
             * 
             */
            "value": Date;
            set(property:"value", value: Date): void;
            get(property:"value"): Date;
            watch(property:"value", callback:{(property?:string, oldValue?:Date, newValue?: Date):void}) :{unwatch():void}
            /**
             * 
             */
            "weekTemplateString": string;
            set(property:"weekTemplateString", value: string): void;
            get(property:"weekTemplateString"): string;
            watch(property:"weekTemplateString", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: String, value: Object): any;
            /**
             * This method is deprecated, use get() or set() directly.
             * 
             * @param name The property to get or set. If an object is passed here and nota string, its keys are used as names of attributes to be setand the value of the object as values to set in the widget.             
             * @param value               OptionalOptional. If provided, attr() operates as a setter. If omitted,the current value of the named property is returned.             
             */
            attr(name: Object, value: Object): any;
            /**
             * 
             */
            buildRendering(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: String): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: String, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: Object, event: Function, method: Function): any;
            /**
             * Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
             * 
             * Connects specified obj/event to specified method of this object
             * and registers for disconnect() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.connect, except with the
             * implicit use of this widget as the target object.
             * Events connected with this.connect are disconnected upon
             * destruction.
             * 
             * @param obj             
             * @param event             
             * @param method             
             */
            connect(obj: any, event: Function, method: Function): any;
            /**
             * Wrapper to setTimeout to avoid deferred functions executing
             * after the originating widget has been destroyed.
             * Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
             * 
             * @param fcn Function reference.             
             * @param delay               OptionalDelay, defaults to 0.             
             */
            defer(fcn: Function, delay: number): Object;
            /**
             * Destroy this widget, but not its descendants.  Descendants means widgets inside of
             * this.containerNode.   Will also destroy any resources (including widgets) registered via this.own().
             * 
             * This method will also destroy internal widgets such as those created from a template,
             * assuming those widgets exist inside of this.domNode but outside of this.containerNode.
             * 
             * For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
             * depend on the current ability to destroy a widget without destroying its descendants.   Generally
             * they should use destroyRecursive() for widgets with children.
             * 
             * @param preserveDom If true, this method will leave the original DOM structure alone.Note: This will not yet work with _TemplatedMixin widgets             
             */
            destroy(preserveDom?: boolean): void;
            /**
             * Recursively destroy the children of this widget and their
             * descendants.
             * 
             * @param preserveDom               OptionalIf true, the preserveDom attribute is passed to all descendantwidget's .destroy() method. Not for use with _Templatedwidgets.             
             */
            destroyDescendants(preserveDom?: boolean): void;
            /**
             * Destroy this widget and its descendants
             * This is the generic "destructor" function that all widget users
             * should call to cleanly discard with a widget. Once a widget is
             * destroyed, it is removed from the manager object.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structurealone of descendant Widgets. Note: This will NOT work withdijit._TemplatedMixin widgets.             
             */
            destroyRecursive(preserveDom?: boolean): void;
            /**
             * Destroys the DOM nodes associated with this widget.
             * 
             * @param preserveDom               OptionalIf true, this method will leave the original DOM structure aloneduring tear-down. Note: this will not work with _Templatedwidgets yet.             
             */
            destroyRendering(preserveDom?: boolean): void;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Disconnects handle created by connect.
             * 
             * @param handle             
             */
            disconnect(handle: any): void;
            /**
             * Used by widgets to signal that a synthetic event occurred, ex:
             * 
             * myWidget.emit("attrmodified-selectedChildWidget", {}).
             * Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
             * Also calls onType() method, if present, and returns value from that method.
             * By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
             * Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
             * 
             * @param type             
             * @param eventObj               Optional            
             * @param callbackArgs               Optional            
             */
            emit(type: String, eventObj: Object, callbackArgs: any[]): any;
            /**
             * Focus the calendar by focusing one of the calendar cells
             * 
             */
            focus(): void;
            /**
             * Get a property from a widget.
             * Get a named property from a widget. The property may
             * potentially be retrieved via a getter method. If no getter is defined, this
             * just retrieves the object's property.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _getFooAttr(), calling:
             * myWidget.get("foo") would be equivalent to calling
             * widget._getFooAttr() and myWidget.get("bar")
             * would be equivalent to the expression
             * widget.bar2
             * 
             * @param name The property to get.             
             */
            get(name: any): any;
            /**
             * Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
             * is this widget.   Note that it does not return all descendants, but rather just direct children.
             * Analogous to Node.childNodes,
             * except containing widgets rather than DOMNodes.
             * 
             * The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
             * outside of this.containerNode.
             * 
             * Note that the array returned is a simple array.  Application code should not assume
             * existence of methods like forEach().
             * 
             */
            getChildren(): any[];
            /**
             * May be overridden to return CSS classes to associate with the date entry for the given dateObject,
             * for example to indicate a holiday in specified locale.
             * 
             * @param dateObject             
             * @param locale               Optional            
             */
            getClassForDate(dateObject: Date, locale: String): String;
            /**
             * Returns all the widgets contained by this, i.e., all widgets underneath this.containerNode.
             * This method should generally be avoided as it returns widgets declared in templates, which are
             * supposed to be internal/hidden, but it's left here for back-compat reasons.
             * 
             */
            getDescendants(): any[];
            /**
             * Returns the parent widget of this widget.
             * 
             */
            getParent(): any;
            /**
             * Sets calendar's value to today's date
             * 
             */
            goToToday(): void;
            /**
             * Provides keyboard navigation of calendar.
             * Called from _onKeyDown() to handle keydown on a stand alone Calendar,
             * and also from dijit/form/_DateTimeTextBox to pass a keydown event
             * from the dijit/form/DateTextBox to be handled in this widget
             * 
             * @param evt             
             */
            handleKey(evt: Event): any;
            /**
             * May be overridden to disable certain dates in the calendar e.g. isDisabledDate=dojo.date.locale.isWeekend
             * 
             * @param dateObject             
             * @param locale               Optional            
             */
            isDisabledDate(dateObject: Date, locale: String): boolean;
            /**
             * Return true if this widget can currently be focused
             * and false if not
             * 
             */
            isFocusable(): any;
            /**
             * Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
             * 
             */
            isLeftToRight(): any;
            /**
             * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
             * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
             * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
             * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
             * 
             * @param type Name of event (ex: "click") or extension event like touch.press.             
             * @param func             
             */
            on(type: String, func: Function): any;
            /**
             * Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
             * Call specified function when event type occurs, ex: myWidget.on("click", function(){ ... }).
             * Note that the function is not run in any particular scope, so if (for example) you want it to run in the
             * widget's scope you must do myWidget.on("click", lang.hitch(myWidget, func)).
             * 
             * @param type Name of event (ex: "click") or extension event like touch.press.             
             * @param func             
             */
            on(type: Function, func: Function): any;
            /**
             * Track specified handles and remove/destroy them when this instance is destroyed, unless they were
             * already removed/destroyed manually.
             * 
             */
            own(): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: String): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: String, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: HTMLElement, position: number): any;
            /**
             * Place this widget somewhere in the DOM based
             * on standard domConstruct.place() conventions.
             * A convenience function provided in all _Widgets, providing a simple
             * shorthand mechanism to put an existing (or newly created) Widget
             * somewhere in the dom, and allow chaining.
             * 
             * @param reference Widget, DOMNode, or id of widget or DOMNode             
             * @param position               OptionalIf reference is a widget (or id of widget), and that widget has an ".addChild" method,it will be called passing this widget instance into that method, supplying the optionalposition index passed.  In this case position (if specified) should be an integer.If reference is a DOMNode (or id matching a DOMNode but not a widget),the position argument can be a numeric index or a string"first", "last", "before", or "after", same as dojo/dom-construct::place().             
             */
            placeAt(reference: dijit._WidgetBase, position: number): any;
            /**
             * 
             */
            postCreate(): void;
            /**
             * Called after the parameters to the widget have been read-in,
             * but before the widget template is instantiated. Especially
             * useful to set properties that are referenced in the widget
             * template.
             * 
             */
            postMixInProperties(): void;
            /**
             * Set a property on a widget
             * Sets named properties on a widget which may potentially be handled by a
             * setter in the widget.
             * 
             * For example, if the widget has properties foo and bar
             * and a method named _setFooAttr(), calling
             * myWidget.set("foo", "Howdy!") would be equivalent to calling
             * widget._setFooAttr("Howdy!") and myWidget.set("bar", 3)
             * would be equivalent to the statement widget.bar = 3;
             * 
             * set() may also be called with a hash of name/value pairs, ex:
             * 
             * myWidget.set({
             *     foo: "Howdy",
             *     bar: 3
             * });
             * This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
             * 
             * @param name The property to set.             
             * @param value The value to set in the property.             
             */
            set(name: any, value: any): any;
            /**
             * Deprecated.  Use set() instead.
             * 
             * @param attr             
             * @param value             
             */
            setAttribute(attr: String, value: any): void;
            /**
             * Deprecated.   Use set('value', ...) instead.
             * 
             * @param value             
             */
            setValue(value: Date): void;
            /**
             * Processing after the DOM fragment is added to the document
             * Called after a widget and its children have been created and added to the page,
             * and all related widgets have finished their create() cycle, up through postCreate().
             * 
             * Note that startup() may be called while the widget is still hidden, for example if the widget is
             * inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
             * For widgets that need to do layout, it's best to put that layout code inside resize(), and then
             * extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
             * 
             */
            startup(): void;
            /**
             * Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
             * 
             * Subscribes to the specified topic and calls the specified method
             * of this object and registers for unsubscribe() on widget destroy.
             * 
             * Provide widget-specific analog to dojo.subscribe, except with the
             * implicit use of this widget as the target object.
             * 
             * @param t The topic             
             * @param method The callback             
             */
            subscribe(t: String, method: Function): any;
            /**
             * Returns a string that represents the widget.
             * When a widget is cast to a string, this method will be used to generate the
             * output. Currently, it does not implement any sort of reversible
             * serialization.
             * 
             */
            toString(): string;
            /**
             * Deprecated. Override destroy() instead to implement custom widget tear-down
             * behavior.
             * 
             */
            uninitialize(): boolean;
            /**
             * Deprecated, will be removed in 2.0, use handle.remove() instead.
             * 
             * Unsubscribes handle created by this.subscribe.
             * Also removes handle from this widget's list of subscriptions
             * 
             * @param handle             
             */
            unsubscribe(handle: Object): void;
            /**
             * Watches a property for changes
             * 
             * @param name               OptionalIndicates the property to watch. This is optional (the callback may be theonly parameter), and if omitted, all the properties will be watched             
             * @param callback The function to execute when the property changes. This will be called afterthe property has been changed. The callback will be called with the |this|set to the instance, the first argument as the name of the property, thesecond argument as the old value and the third argument as the new value.             
             */
            watch(property: string, callback:{(property?:string, oldValue?:any, newValue?: any):void}) :{unwatch():void};
            /**
             * Static method to get a template based on the templatePath or
             * templateString key
             */
            getCachedTemplate(): any;
            /**
             * Called when the widget stops being "active" because
             * focus moved to something outside of it, or the user
             * clicked somewhere outside of it, or the widget was
             * hidden.
             * 
             */
            onBlur(): void;
            /**
             * 
             * @param value             
             */
            onChange(value: any): void;
            /**
             * Connect to this function to receive notifications of mouse click events.
             * 
             * @param event mouse Event             
             */
            onClick(event: any): void;
            /**
             * Called when this widget is being displayed as a popup (ex: a Calendar popped
             * up from a DateTextBox), and it is hidden.
             * This is called from the dijit.popup code, and should not be called directly.
             * 
             * Also used as a parameter for children of dijit/layout/StackContainer or subclasses.
             * Callback if a user tries to close the child.   Child will be closed if this function returns true.
             * 
             */
            onClose(): boolean;
            /**
             * Connect to this function to receive notifications of mouse double click events.
             * 
             * @param event mouse Event             
             */
            onDblClick(event: any): void;
            /**
             * Called when the widget becomes "active" because
             * it or a widget inside of it either has focus, or has recently
             * been clicked.
             * 
             */
            onFocus(): void;
            /**
             * Called when another widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate hide of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onHide(): void;
            /**
             * Connect to this function to receive notifications of keys being pressed down.
             * 
             * @param event key Event             
             */
            onKeyDown(event: any): void;
            /**
             * Connect to this function to receive notifications of printable keys being typed.
             * 
             * @param event key Event             
             */
            onKeyPress(event: any): void;
            /**
             * Connect to this function to receive notifications of keys being released.
             * 
             * @param event key Event             
             */
            onKeyUp(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is pressed down.
             * 
             * @param event mouse Event             
             */
            onMouseDown(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto this widget.
             * 
             * @param event mouse Event             
             */
            onMouseEnter(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of this widget.
             * 
             * @param event mouse Event             
             */
            onMouseLeave(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves over nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseMove(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves off of nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOut(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse moves onto nodes contained within this widget.
             * 
             * @param event mouse Event             
             */
            onMouseOver(event: any): void;
            /**
             * Connect to this function to receive notifications of when the mouse button is released.
             * 
             * @param event mouse Event             
             */
            onMouseUp(event: any): void;
            /**
             * Called when this widget becomes the selected pane in a
             * dijit/layout/TabContainer, dijit/layout/StackContainer,
             * dijit/layout/AccordionContainer, etc.
             * 
             * Also called to indicate display of a dijit.Dialog, dijit.TooltipDialog, or dijit.TitlePane.
             * 
             */
            onShow(): void;
            /**
             * Deprecated.   Notification that a date cell was selected.  It may be the same as the previous value.
             * Formerly used by dijit/form/_DateTimeTextBox (and thus dijit/form/DateTextBox)
             * to get notification when the user has clicked a date.  Now onExecute() (above) is used.
             * 
             * @param date             
             */
            onValueSelected(date: Date): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/main.place.html
         *
         * Code to place a DOMNode relative to another DOMNode.
         * Load using require(["dijit/place"], function(place){ ... }).
         * 
         */
        interface place {
            /**
             * Position node adjacent or kitty-corner to anchor
             * such that it's fully visible in viewport.
             * Place node such that corner of node touches a corner of
             * aroundNode, and that node is fully visible.
             * 
             * @param node             
             * @param anchor Either a DOMNode or a rectangle (object with x, y, width, height).             
             * @param positions Ordered list of positions to try matching up.before: places drop down to the left of the anchor node/widget, or to the right in the case  of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down  with the top of the anchor, or the bottom of the drop down with bottom of the anchor.after: places drop down to the right of the anchor node/widget, or to the left in the case  of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down  with the top of the anchor, or the bottom of the drop down with bottom of the anchor.before-centered: centers drop down to the left of the anchor node/widget, or to the right  in the case of RTL scripts like Hebrew and Arabicafter-centered: centers drop down to the right of the anchor node/widget, or to the left  in the case of RTL scripts like Hebrew and Arabicabove-centered: drop down is centered above anchor nodeabove: drop down goes above anchor node, left sides alignedabove-alt: drop down goes above anchor node, right sides alignedbelow-centered: drop down is centered above anchor nodebelow: drop down goes below anchor nodebelow-alt: drop down goes below anchor node, right sides aligned             
             * @param leftToRight True if widget is LTR, false if widget is RTL.   Affects the behavior of "above" and "below"positions slightly.             
             * @param layoutNode               OptionalFor things like tooltip, they are displayed differently (and have different dimensions)based on their orientation relative to the parent.   This adjusts the popup based on orientation.             
             */
            around(node: HTMLElement, anchor: HTMLElement, positions: String[], leftToRight: boolean, layoutNode: Function): any;
            /**
             * Position node adjacent or kitty-corner to anchor
             * such that it's fully visible in viewport.
             * Place node such that corner of node touches a corner of
             * aroundNode, and that node is fully visible.
             * 
             * @param node             
             * @param anchor Either a DOMNode or a rectangle (object with x, y, width, height).             
             * @param positions Ordered list of positions to try matching up.before: places drop down to the left of the anchor node/widget, or to the right in the case  of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down  with the top of the anchor, or the bottom of the drop down with bottom of the anchor.after: places drop down to the right of the anchor node/widget, or to the left in the case  of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down  with the top of the anchor, or the bottom of the drop down with bottom of the anchor.before-centered: centers drop down to the left of the anchor node/widget, or to the right  in the case of RTL scripts like Hebrew and Arabicafter-centered: centers drop down to the right of the anchor node/widget, or to the left  in the case of RTL scripts like Hebrew and Arabicabove-centered: drop down is centered above anchor nodeabove: drop down goes above anchor node, left sides alignedabove-alt: drop down goes above anchor node, right sides alignedbelow-centered: drop down is centered above anchor nodebelow: drop down goes below anchor nodebelow-alt: drop down goes below anchor node, right sides aligned             
             * @param leftToRight True if widget is LTR, false if widget is RTL.   Affects the behavior of "above" and "below"positions slightly.             
             * @param layoutNode               OptionalFor things like tooltip, they are displayed differently (and have different dimensions)based on their orientation relative to the parent.   This adjusts the popup based on orientation.             
             */
            around(node: HTMLElement, anchor:  dijit.place.__Rectangle, positions: String[], leftToRight: boolean, layoutNode: Function): any;
            /**
             * Positions node kitty-corner to the rectangle centered at (pos.x, pos.y) with width and height of
             * padding.x  2 and padding.y  2, or zero if padding not specified.  Picks first corner in corners[]
             * where node is fully visible, or the corner where it's most visible.
             * 
             * Node is assumed to be absolutely or relatively positioned.
             * 
             * @param node The node to position             
             * @param pos Object like {x: 10, y: 20}             
             * @param corners Array of Strings representing order to try corners of the node in, like ["TR", "BL"].Possible values are:"BL" - bottom left"BR" - bottom right"TL" - top left"TR" - top right             
             * @param padding               OptionalOptional param to set padding, to put some buffer around the element you want to position.Defaults to zero.             
             * @param layoutNode For things like tooltip, they are displayed differently (and have different dimensions)based on their orientation relative to the parent.  This adjusts the popup based on orientation.             
             */
            at(node: HTMLElement, pos: dijit.place.__Position, corners: String[], padding: dijit.place.__Position, layoutNode: any): any;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/main.registry.html
         *
         * Registry of existing widget on page, plus some utility methods.
         * 
         */
        interface registry {
            /**
             * Number of registered widgets
             * 
             */
            length: number;
            /**
             * Add a widget to the registry. If a duplicate ID is detected, a error is thrown.
             * 
             * @param widget Any dijit/_WidgetBase subclass.             
             */
            add(widget: dijit._WidgetBase): void;
            /**
             * Find a widget by it's id.
             * If passed a widget then just returns the widget.
             * 
             * @param id             
             */
            byId(id: String): dijit._WidgetBase;
            /**
             * Find a widget by it's id.
             * If passed a widget then just returns the widget.
             * 
             * @param id             
             */
            byId(id: dijit._WidgetBase): dijit._WidgetBase;
            /**
             * Returns the widget corresponding to the given DOMNode
             * 
             * @param node             
             */
            byNode(node: HTMLElement): any;
            /**
             * Search subtree under root returning widgets found.
             * Doesn't search for nested widgets (ie, widgets inside other widgets).
             * 
             * @param root Node to search under.             
             * @param skipNode If specified, don't search beneath this node (usually containerNode).             
             */
            findWidgets(root: HTMLElement, skipNode: HTMLElement): any[];
            /**
             * Returns the widget whose DOM tree contains the specified DOMNode, or null if
             * the node is not contained within the DOM tree of any widget
             * 
             * @param node             
             */
            getEnclosingWidget(node: HTMLElement): any;
            /**
             * Generates a unique id for a given widgetType
             * 
             * @param widgetType             
             */
            getUniqueId(widgetType: String): String;
            /**
             * Remove a widget from the registry. Does not destroy the widget; simply
             * removes the reference.
             * 
             * @param id             
             */
            remove(id: String): void;
            /**
             * Convert registry into a true Array
             * 
             */
            toArray(): any[];
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/main.typematic.html
         *
         * These functions are used to repetitively call a user specified callback
         * method when a specific key or mouse click over a specific DOM node is
         * held down for a specific amount of time.
         * Only 1 such event is allowed to occur on the browser page at 1 time.
         * 
         */
        interface typematic {
            /**
             * Start listening for a specific typematic key.
             * See also the trigger method for other parameters.
             * 
             * @param node             
             * @param keyObject an object defining the key to listen for:keyCode: the keyCode (number) to listen for, used for non-printable keyscharCode: the charCode (number) to listen for, used for printable keyscharOrCode: deprecated, use keyCode or charCodectrlKey: desired ctrl key state to initiate the callback sequence:pressed (true)released (false)either (unspecified)altKey: same as ctrlKey but for the alt keyshiftKey: same as ctrlKey but for the shift key             
             * @param _this             
             * @param callback             
             * @param subsequentDelay             
             * @param initialDelay             
             * @param minDelay               Optional            
             */
            addKeyListener(node: HTMLElement, keyObject: Object, _this: Object, callback: Function, subsequentDelay: number, initialDelay: number, minDelay: number): any;
            /**
             * Start listening for a specific typematic key and mouseclick.
             * This is a thin wrapper to addKeyListener and addMouseListener.
             * See the addMouseListener and addKeyListener methods for other parameters.
             * 
             * @param mouseNode the DOM node object to listen on for mouse events.             
             * @param keyNode the DOM node object to listen on for key events.             
             * @param keyObject             
             * @param _this             
             * @param callback             
             * @param subsequentDelay             
             * @param initialDelay             
             * @param minDelay               Optional            
             */
            addListener(mouseNode: HTMLElement, keyNode: HTMLElement, keyObject: Object, _this: Object, callback: Function, subsequentDelay: number, initialDelay: number, minDelay: number): any;
            /**
             * Start listening for a typematic mouse click.
             * See the trigger method for other parameters.
             * 
             * @param node             
             * @param _this             
             * @param callback             
             * @param subsequentDelay             
             * @param initialDelay             
             * @param minDelay               Optional            
             */
            addMouseListener(node: HTMLElement, _this: Object, callback: Function, subsequentDelay: number, initialDelay: number, minDelay: number): any;
            /**
             * Stop an ongoing timed, repeating callback sequence.
             * 
             */
            stop(): void;
            /**
             * Start a timed, repeating callback sequence.
             * If already started, the function call is ignored.
             * This method is not normally called by the user but can be
             * when the normal listener code is insufficient.
             * 
             * @param evt key or mouse event object             
             * @param _this pointer to the user's widget space.             
             * @param node the DOM node object passed in             
             * @param callback function to call until the sequence is stopped called with 3 parameters:             
             * @param obj user space object used to uniquely identify each typematic sequence             
             * @param subsequentDelay               Optionalif > 1, the number of milliseconds until the 3->n events occuror else the fractional time multiplier for the next event's delay, default=0.9             
             * @param initialDelay               Optionalthe number of milliseconds until the 2nd event occurs, default=500ms             
             * @param minDelay               Optionalthe maximum delay in milliseconds for event to fire, default=10ms             
             */
            trigger(evt: Event, _this: Object, node: HTMLElement, callback: Function, obj: Object, subsequentDelay: number, initialDelay: number, minDelay: number): void;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/place.html
     *
     * Code to place a DOMNode relative to another DOMNode.
     * Load using require(["dijit/place"], function(place){ ... }).
     * 
     */
    interface place {
        /**
         * Position node adjacent or kitty-corner to anchor
         * such that it's fully visible in viewport.
         * Place node such that corner of node touches a corner of
         * aroundNode, and that node is fully visible.
         * 
         * @param node             
         * @param anchor Either a DOMNode or a rectangle (object with x, y, width, height).             
         * @param positions Ordered list of positions to try matching up.before: places drop down to the left of the anchor node/widget, or to the right in the case  of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down  with the top of the anchor, or the bottom of the drop down with bottom of the anchor.after: places drop down to the right of the anchor node/widget, or to the left in the case  of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down  with the top of the anchor, or the bottom of the drop down with bottom of the anchor.before-centered: centers drop down to the left of the anchor node/widget, or to the right  in the case of RTL scripts like Hebrew and Arabicafter-centered: centers drop down to the right of the anchor node/widget, or to the left  in the case of RTL scripts like Hebrew and Arabicabove-centered: drop down is centered above anchor nodeabove: drop down goes above anchor node, left sides alignedabove-alt: drop down goes above anchor node, right sides alignedbelow-centered: drop down is centered above anchor nodebelow: drop down goes below anchor nodebelow-alt: drop down goes below anchor node, right sides aligned             
         * @param leftToRight True if widget is LTR, false if widget is RTL.   Affects the behavior of "above" and "below"positions slightly.             
         * @param layoutNode               OptionalFor things like tooltip, they are displayed differently (and have different dimensions)based on their orientation relative to the parent.   This adjusts the popup based on orientation.             
         */
        around(node: HTMLElement, anchor: HTMLElement, positions: String[], leftToRight: boolean, layoutNode: Function): any;
        /**
         * Position node adjacent or kitty-corner to anchor
         * such that it's fully visible in viewport.
         * Place node such that corner of node touches a corner of
         * aroundNode, and that node is fully visible.
         * 
         * @param node             
         * @param anchor Either a DOMNode or a rectangle (object with x, y, width, height).             
         * @param positions Ordered list of positions to try matching up.before: places drop down to the left of the anchor node/widget, or to the right in the case  of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down  with the top of the anchor, or the bottom of the drop down with bottom of the anchor.after: places drop down to the right of the anchor node/widget, or to the left in the case  of RTL scripts like Hebrew and Arabic; aligns either the top of the drop down  with the top of the anchor, or the bottom of the drop down with bottom of the anchor.before-centered: centers drop down to the left of the anchor node/widget, or to the right  in the case of RTL scripts like Hebrew and Arabicafter-centered: centers drop down to the right of the anchor node/widget, or to the left  in the case of RTL scripts like Hebrew and Arabicabove-centered: drop down is centered above anchor nodeabove: drop down goes above anchor node, left sides alignedabove-alt: drop down goes above anchor node, right sides alignedbelow-centered: drop down is centered above anchor nodebelow: drop down goes below anchor nodebelow-alt: drop down goes below anchor node, right sides aligned             
         * @param leftToRight True if widget is LTR, false if widget is RTL.   Affects the behavior of "above" and "below"positions slightly.             
         * @param layoutNode               OptionalFor things like tooltip, they are displayed differently (and have different dimensions)based on their orientation relative to the parent.   This adjusts the popup based on orientation.             
         */
        around(node: HTMLElement, anchor:  dijit.place.__Rectangle, positions: String[], leftToRight: boolean, layoutNode: Function): any;
        /**
         * Positions node kitty-corner to the rectangle centered at (pos.x, pos.y) with width and height of
         * padding.x  2 and padding.y  2, or zero if padding not specified.  Picks first corner in corners[]
         * where node is fully visible, or the corner where it's most visible.
         * 
         * Node is assumed to be absolutely or relatively positioned.
         * 
         * @param node The node to position             
         * @param pos Object like {x: 10, y: 20}             
         * @param corners Array of Strings representing order to try corners of the node in, like ["TR", "BL"].Possible values are:"BL" - bottom left"BR" - bottom right"TL" - top left"TR" - top right             
         * @param padding               OptionalOptional param to set padding, to put some buffer around the element you want to position.Defaults to zero.             
         * @param layoutNode For things like tooltip, they are displayed differently (and have different dimensions)based on their orientation relative to the parent.  This adjusts the popup based on orientation.             
         */
        at(node: HTMLElement, pos: dijit.place.__Position, corners: String[], padding: dijit.place.__Position, layoutNode: any): any;
    }
    module place {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/place.__Position.html
         *
         * 
         */
        interface __Position {
            /**
             * horizontal coordinate in pixels, relative to document body
             * 
             */
            x: number;
            /**
             * vertical coordinate in pixels, relative to document body
             * 
             */
            y: number;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/place.__Rectangle.html
         *
         * 
         */
        interface __Rectangle {
            /**
             * height in pixels.   Can also be specified as "height" for backwards-compatibility.
             * 
             */
            h: number;
            /**
             * width in pixels.   Can also be specified as "width" for backwards-compatibility.
             * 
             */
            w: number;
            /**
             * horizontal offset in pixels, relative to document body
             * 
             */
            x: number;
            /**
             * vertical offset in pixels, relative to document body
             * 
             */
            y: number;
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/registry.html
     *
     * Registry of existing widget on page, plus some utility methods.
     * 
     */
    interface registry {
        /**
         * Number of registered widgets
         * 
         */
        length: number;
        /**
         * Add a widget to the registry. If a duplicate ID is detected, a error is thrown.
         * 
         * @param widget Any dijit/_WidgetBase subclass.             
         */
        add(widget: dijit._WidgetBase): void;
        /**
         * Find a widget by it's id.
         * If passed a widget then just returns the widget.
         * 
         * @param id             
         */
        byId(id: String): dijit._WidgetBase;
        /**
         * Find a widget by it's id.
         * If passed a widget then just returns the widget.
         * 
         * @param id             
         */
        byId(id: dijit._WidgetBase): dijit._WidgetBase;
        /**
         * Returns the widget corresponding to the given DOMNode
         * 
         * @param node             
         */
        byNode(node: HTMLElement): any;
        /**
         * Search subtree under root returning widgets found.
         * Doesn't search for nested widgets (ie, widgets inside other widgets).
         * 
         * @param root Node to search under.             
         * @param skipNode If specified, don't search beneath this node (usually containerNode).             
         */
        findWidgets(root: HTMLElement, skipNode: HTMLElement): any[];
        /**
         * Returns the widget whose DOM tree contains the specified DOMNode, or null if
         * the node is not contained within the DOM tree of any widget
         * 
         * @param node             
         */
        getEnclosingWidget(node: HTMLElement): any;
        /**
         * Generates a unique id for a given widgetType
         * 
         * @param widgetType             
         */
        getUniqueId(widgetType: String): String;
        /**
         * Remove a widget from the registry. Does not destroy the widget; simply
         * removes the reference.
         * 
         * @param id             
         */
        remove(id: String): void;
        /**
         * Convert registry into a true Array
         * 
         */
        toArray(): any[];
    }
    module registry {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dijit/registry._hash.html
         *
         * 
         */
        interface _hash {
        }
    }

    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/typematic.html
     *
     * These functions are used to repetitively call a user specified callback
     * method when a specific key or mouse click over a specific DOM node is
     * held down for a specific amount of time.
     * Only 1 such event is allowed to occur on the browser page at 1 time.
     * 
     */
    interface typematic {
        /**
         * Start listening for a specific typematic key.
         * See also the trigger method for other parameters.
         * 
         * @param node             
         * @param keyObject an object defining the key to listen for:keyCode: the keyCode (number) to listen for, used for non-printable keyscharCode: the charCode (number) to listen for, used for printable keyscharOrCode: deprecated, use keyCode or charCodectrlKey: desired ctrl key state to initiate the callback sequence:pressed (true)released (false)either (unspecified)altKey: same as ctrlKey but for the alt keyshiftKey: same as ctrlKey but for the shift key             
         * @param _this             
         * @param callback             
         * @param subsequentDelay             
         * @param initialDelay             
         * @param minDelay               Optional            
         */
        addKeyListener(node: HTMLElement, keyObject: Object, _this: Object, callback: Function, subsequentDelay: number, initialDelay: number, minDelay: number): any;
        /**
         * Start listening for a specific typematic key and mouseclick.
         * This is a thin wrapper to addKeyListener and addMouseListener.
         * See the addMouseListener and addKeyListener methods for other parameters.
         * 
         * @param mouseNode the DOM node object to listen on for mouse events.             
         * @param keyNode the DOM node object to listen on for key events.             
         * @param keyObject             
         * @param _this             
         * @param callback             
         * @param subsequentDelay             
         * @param initialDelay             
         * @param minDelay               Optional            
         */
        addListener(mouseNode: HTMLElement, keyNode: HTMLElement, keyObject: Object, _this: Object, callback: Function, subsequentDelay: number, initialDelay: number, minDelay: number): any;
        /**
         * Start listening for a typematic mouse click.
         * See the trigger method for other parameters.
         * 
         * @param node             
         * @param _this             
         * @param callback             
         * @param subsequentDelay             
         * @param initialDelay             
         * @param minDelay               Optional            
         */
        addMouseListener(node: HTMLElement, _this: Object, callback: Function, subsequentDelay: number, initialDelay: number, minDelay: number): any;
        /**
         * Stop an ongoing timed, repeating callback sequence.
         * 
         */
        stop(): void;
        /**
         * Start a timed, repeating callback sequence.
         * If already started, the function call is ignored.
         * This method is not normally called by the user but can be
         * when the normal listener code is insufficient.
         * 
         * @param evt key or mouse event object             
         * @param _this pointer to the user's widget space.             
         * @param node the DOM node object passed in             
         * @param callback function to call until the sequence is stopped called with 3 parameters:             
         * @param obj user space object used to uniquely identify each typematic sequence             
         * @param subsequentDelay               Optionalif > 1, the number of milliseconds until the 3->n events occuror else the fractional time multiplier for the next event's delay, default=0.9             
         * @param initialDelay               Optionalthe number of milliseconds until the 2nd event occurs, default=500ms             
         * @param minDelay               Optionalthe maximum delay in milliseconds for event to fire, default=10ms             
         */
        trigger(evt: Event, _this: Object, node: HTMLElement, callback: Function, obj: Object, subsequentDelay: number, initialDelay: number, minDelay: number): void;
    }
    /**
     * Permalink: http://dojotoolkit.org/api/1.9/dijit/Viewport.html
     *
     * Utility singleton to watch for viewport resizes, avoiding duplicate notifications
     * which can lead to infinite loops.
     * Usage: Viewport.on("resize", myCallback).
     * 
     * myCallback() is called without arguments in case it's _WidgetBase.resize(),
     * which would interpret the argument as the size to make the widget.
     * 
     */
    interface Viewport {
    }
}

declare module "dijit/_BidiSupport" {
    var exp: dijit._BidiSupport
    export=exp;
}
declare module "dijit/BackgroundIframe" {
    var exp: dijit.BackgroundIframe
    export=exp;
}
declare module "dijit/hccss" {
    var exp: dijit.hccss
    export=exp;
}
declare module "dijit/_base" {
    var exp: dijit._base
    export=exp;
}
declare module "dijit/_base/popup" {
    var exp: dijit._base.popup
    export=exp;
}
declare module "dijit/_base/manager" {
    var exp: dijit._base.manager
    export=exp;
}
declare module "dijit/_base/place" {
    var exp: dijit._base.place
    export=exp;
}
declare module "dijit/_base/focus" {
    var exp: dijit._base.focus
    export=exp;
}
declare module "dijit/_base/scroll" {
    var exp: dijit._base.scroll
    export=exp;
}
declare module "dijit/_base/sniff" {
    var exp: dijit._base.sniff
    export=exp;
}
declare module "dijit/_base/typematic" {
    var exp: dijit._base.typematic
    export=exp;
}
declare module "dijit/_base/window" {
    var exp: dijit._base.window
    export=exp;
}
declare module "dijit/_base/wai" {
    var exp: dijit._base.wai
    export=exp;
}
declare module "dijit/_BidiMixin" {
    var exp: dijit._BidiMixin
    export=exp;
}
declare module "dijit/_Calendar" {
    var exp: dijit._Calendar
    export=exp;
}
declare module "dijit/a11y" {
    var exp: dijit.a11y
    export=exp;
}
declare module "dijit/a11yclick" {
    var exp: dijit.a11yclick
    export=exp;
}
declare module "dijit/dijit" {
    var exp: dijit.dijit
    export=exp;
}
declare module "dijit/dijit-all" {
    var exp: dijit.dijit_all
    export=exp;
}
declare module "dijit/main" {
    var exp: dijit.main
    export=exp;
}
declare module "dijit/main._Calendar" {
    var exp: dijit.main._Calendar
    export=exp;
}
declare module "dijit/main.place" {
    var exp: dijit.main.place
    export=exp;
}
declare module "dijit/main.typematic" {
    var exp: dijit.main.typematic
    export=exp;
}
declare module "dijit/main.registry" {
    var exp: dijit.main.registry
    export=exp;
}
declare module "dijit/place" {
    var exp: dijit.place
    export=exp;
}
declare module "dijit/place.__Rectangle" {
    var exp: dijit.place.__Rectangle
    export=exp;
}
declare module "dijit/place.__Position" {
    var exp: dijit.place.__Position
    export=exp;
}
declare module "dijit/registry" {
    var exp: dijit.registry
    export=exp;
}
declare module "dijit/registry._hash" {
    var exp: dijit.registry._hash
    export=exp;
}
declare module "dijit/typematic" {
    var exp: dijit.typematic
    export=exp;
}
declare module "dijit/Viewport" {
    var exp: dijit.Viewport
    export=exp;
}
declare module "dijit/_AttachMixin" {
    var exp: typeof dijit._AttachMixin
    export=exp;
}
declare module "dijit/_Contained" {
    var exp: typeof dijit._Contained
    export=exp;
}
declare module "dijit/_Container" {
    var exp: typeof dijit._Container
    export=exp;
}
declare module "dijit/_DialogMixin" {
    var exp: typeof dijit._DialogMixin
    export=exp;
}
declare module "dijit/_CssStateMixin" {
    var exp: typeof dijit._CssStateMixin
    export=exp;
}
declare module "dijit/_FocusMixin" {
    var exp: typeof dijit._FocusMixin
    export=exp;
}
declare module "dijit/_HasDropDown" {
    var exp: typeof dijit._HasDropDown
    export=exp;
}
declare module "dijit/_KeyNavMixin" {
    var exp: typeof dijit._KeyNavMixin
    export=exp;
}
declare module "dijit/_KeyNavContainer" {
    var exp: typeof dijit._KeyNavContainer
    export=exp;
}
declare module "dijit/_OnDijitClickMixin" {
    var exp: typeof dijit._OnDijitClickMixin
    export=exp;
}
declare module "dijit/_OnDijitClickMixin.a11yclick" {
    var exp: dijit._OnDijitClickMixin.a11yclick
    export=exp;
}
declare module "dijit/_Templated" {
    var exp: typeof dijit._Templated
    export=exp;
}
declare module "dijit/_TemplatedMixin" {
    var exp: typeof dijit._TemplatedMixin
    export=exp;
}
declare module "dijit/_TemplatedMixin._templateCache" {
    var exp: dijit._TemplatedMixin._templateCache
    export=exp;
}
declare module "dijit/_PaletteMixin" {
    var exp: typeof dijit._PaletteMixin
    export=exp;
}
declare module "dijit/_PaletteMixin.__Dye" {
    var exp: typeof dijit._PaletteMixin.__Dye
    export=exp;
}
declare module "dijit/_MenuBase" {
    var exp: typeof dijit._MenuBase
    export=exp;
}
declare module "dijit/_TimePicker" {
    var exp: typeof dijit._TimePicker
    export=exp;
}
declare module "dijit/_TimePicker.__Constraints" {
    var exp: typeof dijit._TimePicker.__Constraints
    export=exp;
}
declare module "dijit/_WidgetsInTemplateMixin" {
    var exp: typeof dijit._WidgetsInTemplateMixin
    export=exp;
}
declare module "dijit/_WidgetBase" {
    var exp: typeof dijit._WidgetBase
    export=exp;
}
declare module "dijit/_Widget" {
    var exp: typeof dijit._Widget
    export=exp;
}
declare module "dijit/Destroyable" {
    var exp: typeof dijit.Destroyable
    export=exp;
}
declare module "dijit/Calendar" {
    var exp: typeof dijit.Calendar
    export=exp;
}
declare module "dijit/Calendar._MonthDropDown" {
    var exp: typeof dijit.Calendar._MonthDropDown
    export=exp;
}
declare module "dijit/Calendar._MonthDropDownButton" {
    var exp: typeof dijit.Calendar._MonthDropDownButton
    export=exp;
}
declare module "dijit/CalendarLite" {
    var exp: typeof dijit.CalendarLite
    export=exp;
}
declare module "dijit/CalendarLite._MonthWidget" {
    var exp: typeof dijit.CalendarLite._MonthWidget
    export=exp;
}
declare module "dijit/CheckedMenuItem" {
    var exp: typeof dijit.CheckedMenuItem
    export=exp;
}
declare module "dijit/ColorPalette" {
    var exp:typeof  dijit.ColorPalette
    export=exp;
}
declare module "dijit/ColorPalette._Color" {
    var exp: typeof dijit.ColorPalette._Color
    export=exp;
}
declare module "dijit/Declaration" {
    var exp: typeof dijit.Declaration
    export=exp;
}
declare module "dijit/DialogUnderlay" {
    var exp: typeof dijit.DialogUnderlay
    export=exp;
}
declare module "dijit/DropDownMenu" {
    var exp: typeof dijit.DropDownMenu
    export=exp;
}
declare module "dijit/Dialog" {
    var exp: typeof dijit.Dialog
    export=exp;
}
declare module "dijit/Dialog._DialogBase" {
    var exp: typeof dijit.Dialog._DialogBase
    export=exp;
}
declare module "dijit/Dialog._DialogLevelManager" {
    var exp: dijit.Dialog._DialogLevelManager
    export=exp;
}
declare module "dijit/Editor" {
    var exp: typeof dijit.Editor
    export=exp;
}
declare module "dijit/Fieldset" {
    var exp: typeof dijit.Fieldset
    export=exp;
}
declare module "dijit/InlineEditBox" {
    var exp: typeof dijit.InlineEditBox
    export=exp;
}
declare module "dijit/InlineEditBox._InlineEditor" {
    var exp: typeof dijit.InlineEditBox._InlineEditor
    export=exp;
}
declare module "dijit/Menu" {
    var exp: typeof dijit.Menu
    export=exp;
}
declare module "dijit/MenuBarItem" {
    var exp: typeof dijit.MenuBarItem
    export=exp;
}
declare module "dijit/MenuBarItem._MenuBarItemMixin" {
    var exp: typeof dijit.MenuBarItem._MenuBarItemMixin
    export=exp;
}
declare module "dijit/MenuSeparator" {
    var exp: typeof dijit.MenuSeparator
    export=exp;
}
declare module "dijit/MenuItem" {
    var exp: typeof dijit.MenuItem
    export=exp;
}
declare module "dijit/MenuBar" {
    var exp:typeof  dijit.MenuBar
    export=exp;
}
declare module "dijit/PopupMenuBarItem" {
    var exp: typeof dijit.PopupMenuBarItem
    export=exp;
}
declare module "dijit/ProgressBar" {
    var exp: typeof dijit.ProgressBar
    export=exp;
}
declare module "dijit/RadioMenuItem" {
    var exp: typeof dijit.RadioMenuItem
    export=exp;
}
declare module "dijit/PopupMenuItem" {
    var exp: typeof dijit.PopupMenuItem
    export=exp;
}
declare module "dijit/TitlePane" {
    var exp: typeof dijit.TitlePane
    export=exp;
}
declare module "dijit/Toolbar" {
    var exp: typeof dijit.Toolbar
    export=exp;
}
declare module "dijit/Tooltip" {
    var exp: typeof dijit.Tooltip
    export=exp;
}
declare module "dijit/Tooltip._MasterTooltip" {
    var exp: typeof dijit.Tooltip._MasterTooltip
    export=exp;
}
declare module "dijit/ToolbarSeparator" {
    var exp: typeof dijit.ToolbarSeparator
    export=exp;
}
declare module "dijit/WidgetSet" {
    var exp: typeof dijit.WidgetSet
    export=exp;
}
declare module "dijit/TooltipDialog" {
    var exp:typeof  dijit.TooltipDialog
    export=exp;
}
declare module "dijit/Tree" {
    var exp: typeof dijit.Tree
    export=exp;
}
declare module "dijit/Tree._TreeNode" {
    var exp: typeof dijit.Tree._TreeNode
    export=exp;
}
declare module "dijit/_editor/html" {
    var exp: dijit._editor.html
    export=exp;
}
declare module "dijit/_editor/range" {
    var exp: dijit._editor.range
    export=exp;
}
declare module "dijit/_editor/range.W3CRange" {
    var exp: typeof dijit._editor.range.W3CRange
    export=exp;
}
declare module "dijit/_editor/range.ie" {
    var exp: dijit._editor.range.ie
    export=exp;
}
declare module "dijit/_editor/selection" {
    var exp: dijit._editor.selection
    export=exp;
}
declare module "dijit/_editor/_Plugin" {
    var exp: typeof dijit._editor._Plugin
    export=exp;
}
declare module "dijit/_editor/_Plugin.registry" {
    var exp: dijit._editor._Plugin.registry
    export=exp;
}
declare module "dijit/_editor/RichText" {
    var exp: typeof dijit._editor.RichText
    export=exp;
}
declare module "dijit/_editor/plugins/AlwaysShowToolbar" {
    var exp: typeof dijit._editor.plugins.AlwaysShowToolbar
    export=exp;
}
declare module "dijit/_editor/plugins/FontChoice" {
    var exp: typeof dijit._editor.plugins.FontChoice
    export=exp;
}
declare module "dijit/_editor/plugins/FontChoice._FontDropDown" {
    var exp: typeof dijit._editor.plugins.FontChoice._FontDropDown
    export=exp;
}
declare module "dijit/_editor/plugins/FontChoice._FontSizeDropDown" {
    var exp: typeof dijit._editor.plugins.FontChoice._FontSizeDropDown
    export=exp;
}
declare module "dijit/_editor/plugins/FontChoice._FontNameDropDown" {
    var exp: typeof dijit._editor.plugins.FontChoice._FontNameDropDown
    export=exp;
}
declare module "dijit/_editor/plugins/FontChoice._FormatBlockDropDown" {
    var exp: typeof dijit._editor.plugins.FontChoice._FormatBlockDropDown
    export=exp;
}
declare module "dijit/_editor/plugins/EnterKeyHandling" {
    var exp: typeof dijit._editor.plugins.EnterKeyHandling
    export=exp;
}
declare module "dijit/_editor/plugins/LinkDialog" {
    var exp: typeof dijit._editor.plugins.LinkDialog
    export=exp;
}
declare module "dijit/_editor/plugins/LinkDialog.ImgLinkDialog" {
    var exp: typeof dijit._editor.plugins.LinkDialog.ImgLinkDialog
    export=exp;
}
declare module "dijit/_editor/plugins/FullScreen" {
    var exp: typeof dijit._editor.plugins.FullScreen
    export=exp;
}
declare module "dijit/_editor/plugins/NewPage" {
    var exp: typeof dijit._editor.plugins.NewPage
    export=exp;
}
declare module "dijit/_editor/plugins/Print" {
    var exp: typeof dijit._editor.plugins.Print
    export=exp;
}
declare module "dijit/_editor/plugins/TabIndent" {
    var exp: typeof dijit._editor.plugins.TabIndent
    export=exp;
}
declare module "dijit/_editor/plugins/TextColor" {
    var exp: typeof dijit._editor.plugins.TextColor
    export=exp;
}
declare module "dijit/_editor/plugins/ToggleDir" {
    var exp: typeof dijit._editor.plugins.ToggleDir
    export=exp;
}
declare module "dijit/_editor/plugins/ViewSource" {
    var exp: typeof dijit._editor.plugins.ViewSource
    export=exp;
}
declare module "dijit/_tree/dndSource" {
    var exp: dijit._tree.dndSource
    export=exp;
}
declare module "dijit/form/Slider" {
    var exp: dijit.form.Slider
    export=exp;
}
declare module "dijit/form/_ButtonMixin" {
    var exp: typeof dijit.form._ButtonMixin
    export=exp;
}
declare module "dijit/form/_AutoCompleterMixin" {
    var exp: typeof dijit.form._AutoCompleterMixin
    export=exp;
}
declare module "dijit/form/_CheckBoxMixin" {
    var exp: typeof dijit.form._CheckBoxMixin
    export=exp;
}
declare module "dijit/form/_ComboBoxMenuMixin" {
    var exp: typeof dijit.form._ComboBoxMenuMixin
    export=exp;
}
declare module "dijit/form/_ExpandingTextAreaMixin" {
    var exp: typeof dijit.form._ExpandingTextAreaMixin
    export=exp;
}
declare module "dijit/form/_FormMixin" {
    var exp: typeof dijit.form._FormMixin
    export=exp;
}
declare module "dijit/form/_FormValueMixin" {
    var exp: typeof dijit.form._FormValueMixin
    export=exp;
}
declare module "dijit/form/_FormWidgetMixin" {
    var exp: typeof dijit.form._FormWidgetMixin
    export=exp;
}
declare module "dijit/form/_ListBase" {
    var exp: typeof dijit.form._ListBase
    export=exp;
}
declare module "dijit/form/_ComboBoxMenu" {
    var exp: typeof dijit.form._ComboBoxMenu
    export=exp;
}
declare module "dijit/form/_RadioButtonMixin" {
    var exp: typeof dijit.form._RadioButtonMixin
    export=exp;
}
declare module "dijit/form/_SearchMixin" {
    var exp: typeof dijit.form._SearchMixin
    export=exp;
}
declare module "dijit/form/_ListMouseMixin" {
    var exp: typeof dijit.form._ListMouseMixin
    export=exp;
}
declare module "dijit/form/_FormSelectWidget" {
    var exp:typeof  dijit.form._FormSelectWidget
    export=exp;
}
declare module "dijit/form/_FormSelectWidget.__SelectOption" {
    var exp: dijit.form._FormSelectWidget.__SelectOption
    export=exp;
}
declare module "dijit/form/_TextBoxMixin" {
    var exp: typeof dijit.form._TextBoxMixin
    export=exp;
}
declare module "dijit/form/_FormWidget" {
    var exp: typeof dijit.form._FormWidget
    export=exp;
}
declare module "dijit/form/_ToggleButtonMixin" {
    var exp: typeof dijit.form._ToggleButtonMixin
    export=exp;
}
declare module "dijit/form/_FormValueWidget" {
    var exp: typeof dijit.form._FormValueWidget
    export=exp;
}
declare module "dijit/form/_DateTimeTextBox" {
    var exp: typeof dijit.form._DateTimeTextBox
    export=exp;
}
declare module "dijit/form/_DateTimeTextBox.__Constraints" {
    var exp: typeof dijit.form._DateTimeTextBox.__Constraints
    export=exp;
}
declare module "dijit/form/ComboBoxMixin" {
    var exp: typeof dijit.form.ComboBoxMixin
    export=exp;
}
declare module "dijit/form/_Spinner" {
    var exp: typeof dijit.form._Spinner
    export=exp;
}
declare module "dijit/form/DataList" {
    var exp: typeof dijit.form.DataList
    export=exp;
}
declare module "dijit/form/Button" {
    var exp: typeof dijit.form.Button
    export=exp;
}
declare module "dijit/form/CheckBox" {
    var exp: typeof dijit.form.CheckBox
    export=exp;
}
declare module "dijit/form/ComboButton" {
    var exp: typeof dijit.form.ComboButton
    export=exp;
}
declare module "dijit/form/ComboBox" {
    var exp: typeof dijit.form.ComboBox
    export=exp;
}
declare module "dijit/form/CurrencyTextBox" {
    var exp: typeof dijit.form.CurrencyTextBox
    export=exp;
}
declare module "dijit/form/DropDownButton" {
    var exp: typeof dijit.form.DropDownButton
    export=exp;
}
declare module "dijit/form/Form" {
    var exp: typeof dijit.form.Form
    export=exp;
}
declare module "dijit/form/DateTextBox" {
    var exp: typeof dijit.form.DateTextBox
    export=exp;
}
declare module "dijit/form/HorizontalRule" {
    var exp: typeof dijit.form.HorizontalRule
    export=exp;
}
declare module "dijit/form/FilteringSelect" {
    var exp: typeof dijit.form.FilteringSelect
    export=exp;
}
declare module "dijit/form/HorizontalRuleLabels" {
    var exp: typeof dijit.form.HorizontalRuleLabels
    export=exp;
}
declare module "dijit/form/HorizontalSlider" {
    var exp: typeof dijit.form.HorizontalSlider
    export=exp;
}
declare module "dijit/form/HorizontalSlider._Mover" {
    var exp: typeof dijit.form.HorizontalSlider._Mover
    export=exp;
}
declare module "dijit/form/MultiSelect" {
    var exp: typeof dijit.form.MultiSelect
    export=exp;
}
declare module "dijit/form/MappedTextBox" {
    var exp: typeof dijit.form.MappedTextBox
    export=exp;
}
declare module "dijit/form/NumberSpinner" {
    var exp: typeof dijit.form.NumberSpinner
    export=exp;
}
declare module "dijit/form/RangeBoundTextBox" {
    var exp: typeof dijit.form.RangeBoundTextBox
    export=exp;
}
declare module "dijit/form/RangeBoundTextBox.__Constraints" {
    var exp: typeof dijit.form.RangeBoundTextBox.__Constraints
    export=exp;
}
declare module "dijit/form/RadioButton" {
    var exp: typeof dijit.form.RadioButton
    export=exp;
}
declare module "dijit/form/NumberTextBox" {
    var exp: typeof dijit.form.NumberTextBox
    export=exp;
}
declare module "dijit/form/NumberTextBox.__Constraints" {
    var exp: typeof dijit.form.NumberTextBox.__Constraints
    export=exp;
}
declare module "dijit/form/NumberTextBox.Mixin" {
    var exp: typeof dijit.form.NumberTextBox.Mixin
    export=exp;
}
declare module "dijit/form/SimpleTextarea" {
    var exp: typeof dijit.form.SimpleTextarea
    export=exp;
}
declare module "dijit/form/Textarea" {
    var exp: typeof dijit.form.Textarea
    export=exp;
}
declare module "dijit/form/Select" {
    var exp: typeof dijit.form.Select
    export=exp;
}
declare module "dijit/form/Select._Menu" {
    var exp: typeof dijit.form.Select._Menu
    export=exp;
}
declare module "dijit/form/TextBox" {
    var exp: typeof dijit.form.TextBox
    export=exp;
}
declare module "dijit/form/VerticalRule" {
    var exp: typeof dijit.form.VerticalRule
    export=exp;
}
declare module "dijit/form/ToggleButton" {
    var exp: typeof dijit.form.ToggleButton
    export=exp;
}
declare module "dijit/form/TimeTextBox" {
    var exp: typeof dijit.form.TimeTextBox
    export=exp;
}
declare module "dijit/form/ValidationTextBox" {
    var exp: typeof dijit.form.ValidationTextBox
    export=exp;
}
declare module "dijit/form/VerticalRuleLabels" {
    var exp: typeof dijit.form.VerticalRuleLabels
    export=exp;
}
declare module "dijit/form/VerticalSlider" {
    var exp: typeof dijit.form.VerticalSlider
    export=exp;
}
declare module "dijit/layout/utils" {
    var exp: dijit.layout.utils
    export=exp;
}
declare module "dijit/layout/_ContentPaneResizeMixin" {
    var exp: typeof dijit.layout._ContentPaneResizeMixin
    export=exp;
}
declare module "dijit/layout/_LayoutWidget" {
    var exp: typeof dijit.layout._LayoutWidget
    export=exp;
}
declare module "dijit/layout/AccordionContainer" {
    var exp: typeof dijit.layout.AccordionContainer
    export=exp;
}
declare module "dijit/layout/AccordionContainer._Button" {
    var exp: typeof dijit.layout.AccordionContainer._Button
    export=exp;
}
declare module "dijit/layout/AccordionContainer._InnerContainer" {
    var exp: typeof dijit.layout.AccordionContainer._InnerContainer
    export=exp;
}
declare module "dijit/layout/_TabContainerBase" {
    var exp: typeof dijit.layout._TabContainerBase
    export=exp;
}
declare module "dijit/layout/AccordionPane" {
    var exp: typeof dijit.layout.AccordionPane
    export=exp;
}
declare module "dijit/layout/BorderContainer" {
    var exp: typeof dijit.layout.BorderContainer
    export=exp;
}
declare module "dijit/layout/BorderContainer._Gutter" {
    var exp: typeof dijit.layout.BorderContainer._Gutter
    export=exp;
}
declare module "dijit/layout/BorderContainer._Splitter" {
    var exp: typeof dijit.layout.BorderContainer._Splitter
    export=exp;
}
declare module "dijit/layout/BorderContainer.ChildWidgetProperties" {
    var exp: dijit.layout.BorderContainer.ChildWidgetProperties
    export=exp;
}
declare module "dijit/layout/LayoutContainer" {
    var exp: typeof dijit.layout.LayoutContainer
    export=exp;
}
declare module "dijit/layout/LayoutContainer.ChildWidgetProperties" {
    var exp: dijit.layout.LayoutContainer.ChildWidgetProperties
    export=exp;
}
declare module "dijit/layout/ContentPane" {
    var exp: typeof dijit.layout.ContentPane
    export=exp;
}
declare module "dijit/layout/LinkPane" {
    var exp: typeof dijit.layout.LinkPane
    export=exp;
}
declare module "dijit/layout/SplitContainer" {
    var exp: typeof dijit.layout.SplitContainer
    export=exp;
}
declare module "dijit/layout/SplitContainer.ChildWidgetProperties" {
    var exp: dijit.layout.SplitContainer.ChildWidgetProperties
    export=exp;
}
declare module "dijit/layout/ScrollingTabController" {
    var exp: typeof dijit.layout.ScrollingTabController
    export=exp;
}
declare module "dijit/layout/StackController" {
    var exp: typeof dijit.layout.StackController
    export=exp;
}
declare module "dijit/layout/StackController.StackButton" {
    var exp: typeof dijit.layout.StackController.StackButton
    export=exp;
}
declare module "dijit/layout/StackContainer" {
    var exp: typeof dijit.layout.StackContainer
    export=exp;
}
declare module "dijit/layout/StackContainer.ChildWidgetProperties" {
    var exp: dijit.layout.StackContainer.ChildWidgetProperties
    export=exp;
}
declare module "dijit/layout/TabContainer" {
    var exp: typeof dijit.layout.TabContainer
    export=exp;
}
declare module "dijit/layout/TabController" {
    var exp: typeof dijit.layout.TabController
    export=exp;
}
declare module "dijit/layout/TabController.TabButton" {
    var exp: typeof dijit.layout.TabController.TabButton
    export=exp;
}
declare module "dijit/tree/_dndContainer" {
    var exp: dijit.tree._dndContainer
    export=exp;
}
declare module "dijit/tree/ForestStoreModel" {
    var exp: typeof dijit.tree.ForestStoreModel
    export=exp;
}
declare module "dijit/tree/dndSource" {
    var exp: dijit.tree.dndSource
    export=exp;
}
declare module "dijit/tree/dndSource.__Item" {
    var exp: dijit.tree.dndSource.__Item
    export=exp;
}
declare module "dijit/tree/model" {
    var exp: dijit.tree.model
    export=exp;
}
declare module "dijit/tree/_dndSelector" { 
    var exp: dijit.tree._dndSelector
    export=exp;
}
declare module "dijit/tree/ObjectStoreModel" {
    var exp: typeof dijit.tree.ObjectStoreModel
    export=exp;
}
declare module "dijit/tree/TreeStoreModel" {
    var exp: typeof dijit.tree.TreeStoreModel
    export=exp;
}

declare module "dijit/ConfirmDialog" {
    var exp: typeof dijit.ConfirmDialog;
    export=exp;
}
declare module "dijit/_ConfirmDialogMixin" {
    var exp: typeof dijit._ConfirmDialogMixin;
    export=exp;
}